[Back to DOS SWAG index] [Back to Main SWAG index] [Original]

    {

       I've been puzzling over Share myself the last week. Here's some
       tips from what I've found:

       1. Remember, if you are trying to write to the same region from
       both processes, you will *still* get a sharing violation with
       access denied to the last one to ask ! There is a subfunc, (440Bh
       I think) for changing the default number of tries that share will
       retry for access. You might want to look into that. Otherwise you
       could use something like the OpenTxtFile routine below, modified
       for use on non-text files, or both. (You aren't trying to share
       text files are you? If so, there IS a way to do it, let me know).

       2. Also note that you set the filemode AFTER assignment, and
       BEFORE a reset, rewrite or append.

       3. The following are 2 functions I've put together to handle my
       stuff. Note that the first is for non-text files, the second is
       for text files. The text file routine uses an external TFDD unit
       to set up the filemode variable so it works with text files.
       Holler if you want the unit also.........

               (* Call this to lock or unlock the ENTIRE file
    ****** use lock =$00 & unlock = $01 constants for action *********
                  ***** SHARE.EXE MUST be loaded ! *******
                 Do NOT use on Text Files ! will NOT work !
    You could modify this to only lock certain regions by passing values
    for a start and stop region. Load CX/DX and DI/SI as done below. *)
    }

    Function LockFile(var f; action:byte):boolean;
    Var
       fsize : longint;
    Begin
     if GotShare then                         (* Share loaded ? *)
       begin
         fsize := longint(filesize(file(f)));   (* Get filesize *)
         Regs.AH := $5C;                             (* Subfunc *)
         Regs.AL := Action;           (* $00=Lock or $01=unlock *)
         Regs.BX := FileRec(f).Handle;        (* Git the handle *)
         Regs.CX := Hi($00);                   (* Start of file *)
         Regs.DX := Lo($00);
         Regs.DI := Lo(fsize);           (* Compute end of file *)
         Regs.SI := Hi(fsize);
         Intr($21, Regs);
         if ((Regs.FLAGS and $01) = 0) then LockFile := true
         else
           begin
             IORes := regs.AX;      (* If fails, errcode is in AX *)
             LockFile := false;    (* IORes is a global that gets *)
           end;                   (* used in IOReport if an error *)
       end;
    End;

    (*-------------------------------------------------------------*)
      (* Share compatable  Will retry if access denied, tries times
               5 Tries is equivilent to a 1/2 second wait

                                      ----- Sharing Method -----
     Access         Compatibility   Deny   Deny    Deny   Deny
     Method            Mode         Both   Write   Read   None
     ---------------------------------------------------------
     Read Only           0           16     32      48     64
     Write Only          1           17     33      49     65
     Read/Write          2*          18     34      50     66
                            * = default                        *)

    FUNCTION OpenTxtFile(var f; fname:string; tries:word):boolean;
    VAR
       i  : word;
    Begin
      i := 0;
     if GotShare then                       (* Share loaded ? *)
       begin
         AssignText(text(f),Fname);         (* From TxtShare unit *)
         FileMode := 34;            (* Open in r/w-deny write mode *)
       end
     else  Assign(text(f),Fname);
     Repeat
      {$I-} Reset(text(f));
      IORes := IoResult; {$I+}
      if IORes = 5 then              (* Only repeat if denied access *)
        begin
          wait(100);                (* Wait 1/10 second before retry *)
          INC(i);                 (* Use your own delay routine here *)
        end
      else i := tries;                (*  Quit if not a sharing deny *)
     Until (IORes = 0) OR (i >= tries);
     if GotShare then FileMode := 2;      (* Set FileMode to default *)
     OpenTxtFile := IORes = 0;
    End;

    {    ****** Here's a quick SHARE detect routine ********* }

    Function ShareInstalled : boolean; assembler;
    asm
      mov ax,$1000
      int $2f
    end;

[Back to DOS SWAG index] [Back to Main SWAG index] [Original]