
  .   .    "OS/2 "                          9


                                      

* ६ ⥭  
* न   ᥬ஢
* न 㭪樥 DosReadAsync()
*  ᥬ  㭪 DosMuxSemWait()
* ६ ⥭  ⮡ࠦ
* ᮢ 䠩 
*  ஢


    ,      ,        䠩 ,
ᬮਬ,  룮    ᯮ짮 䠩   -
뢮  筮 ।.

            ਬ   ணࠬ,    
楯窮 ந  ᫥,   ६ ⠫   
  㣮  楯窮.       ⠪    筮
⢫  ﬨ ᪮   뢮?    ࠡ⠥ 
묨    ॥  .   ,       
 ,  業ࠫ    ᯮ짮  ᢮
६    ᢮  ᫥.     ⮩    ஡㥬 
।⢠,  ᯥ稢騥    筮.     
⨣  ⥫쭮  㢥祭  ᪮  ࠡ  ணࠬ  
 ६  믮 ᪮   -  뢮   㣨
⢨.

     1 -    ᬮਬ ,     
᪮쪨  ᪮  䠩     .         ⥭
ந室 ६,  ᯮ   ࠧ  楯窨. ᬠਢ
᪮쪮 室  ⮩ ஡.

        ᯮ짮  室  室   믮 ࠧ
 ⥫쭮, ஬   ,   䠩   -
뢮.   ணࠬ          䠩,  ६
뢠   , 뫠  ଠ   ਭ,   
 㣮 ᪮ 䠩, 뢮 ଠ  ..

      ணࠬ    ।,  冷,  
஬ 䠩   ,  .   砥  
    頥   ணࠬ.   㣨 
冷  ⥭    ࠡ⪨     .  ਬ  -   ணࠬ,
ᯮ ᪮쪮 楯祪  뢮 ᮤন ᪮  䠩
 ࠭.   ஢ਬ  砩  ன .

    ᫥    㦤  ,   ன   ᪮쪮
ᮢ     䠩 ६.

            

    ।,  ணࠬ  㦭       鸞 
䠩    ஢  .             ࠧ:
⥦      ,   ⥫᪨     ࠪ⭮
⠭, ᪨   ண஢ த  業
権    ᫥  祭   .          
  室      ६  ⥭  
᪠.       ணࠬ    ᯥ祭  ⠪ 
筮?

      ஡ -  न  - 뢮   .    ⮩
    ஡㥬  ᪮쪮  室    ஡.     ᬮਬ
ਬ,    ᮣᮢ    ᯮ,       ஢
ࠧ묨 ᯮᮡ   ᥬ஢.

          䠩 

    ⮡  ,    筮  ਬ     
,  室 䠩 .  ᫥饬 ਬ  ᯮ㥬
8  䠩,     ᮤঠ  10000  楫   祭.    ணࠬ,
ਢ   ,   ᮧ   䠩   ,     
ﭭ묨 祭ﬨ.

/* makedata.c */
/*  䠩 ⠭⠬ */
#define INCL_DOS
#inckude <os2.h>
#define ATTR 0           /* ଠ 䠩 */
#define OPENFLAG 0x0012  /* 祭 ண  ᮧ
                                */
#define OPENMODE 0x0012 /* =/ ᮢ= ᥬ */
#define BUFSIZE 10000L  /* ࠧ   楫 */
#define CHARSIZE (unsigned long) sizeof(buff) /*  ᨬ. */

int buff[BUFSIZE];    /*   */

main(argc,argv)
int argc;
char *argv[];
{
  int konst;             /* ⠭   */
  unsigned short handle; /* 䠩   DosOpen */
  unsigned action;       /* ⢨  DosOpen */
  unsigned BytesWritten; /* , 뢠 DosWrite */
  int n;                 /* 稪 横 */
   if(argc !=3)
    { printf("Syntax: makedata filename constant");
                                                 exit(1); }
         /*   ⠭⠬ */
  konst = atoi(argv[2]);
  for (n=0; n<BUFSIZE; n++)
     buff[n] = konst;
                         /* ⨥ 䠩 */
  DosOpen(argv[1], &handle, &action, CHARSIZE,
                          ATTR, OPENFLAG, OPENMODE, 0L );
                         /*   䠩 */
  DosWrite(handle, (char far *)buff, CHARSIZE,
                                         &BytesWritten );
  DosClose(handle);      /*  䠩 */
  exit(0);
}


    ⨬,   ⮩ ணࠬ,    ᫥  ⮩ ,  
ࠫ    訡   맮  API -  㭪権, ⮡ ணࠬ
뫨   㦭   蠫 ᬠਢ ࠡ ணࠬ.  
  ⮬      .       ᢮ ணࠬ,  㤥
 ।  ஢ન     API - 㭪権  
㢥   㫥 祭.      訡    㤥
,   ᪠.  㤭  ⫠.

    ணࠬ makefile.c    ⢥ 㬥   ப
  ᮧ  䠩    ⠭   .  ணࠬ
     ।,          䠩,    뢠   SRC0.DAT,
SRC1.DAT,...SRC7.DAT. SRC0.DAT   0s,  SRC1.DAT -  1s  ..
 ,   塞    ணࠬ, 
  .  ᮧ  䠩 맮 ணࠬ makefile.c ⠪:

C>makefile src0.dat 0
C>makefile src1.dat 1
C>makefile src2.dat 2
- - - - - - - - - - -
C>makefile src7.dat 7


     ।,   ᮧ  䠩  ࠧ⨫   ⮬ 
४ਨ,    ஬  㤥  믮  ਬ  ணࠬ.  (
祪 뢠 饭  ⪮ ).

          室

    ᬮ,      㥬    䠩   
ᯮᮡ.    ਬ seridata.c, ..  믮  ⥭
  ᫥⥫쭮,   ६.

/* seridata.c */
/*   ᪮ 䠩 */
#define INCL_DOS
#include <os2.h>
#define ATTR 0           /* ଠ 䠩 */
#define OPENFLAG 0x01    /* ᡮ, ᫨ 䠩 , 
                               */
#define OPENMODE 0x0040 /* =-  ᮢ= ⮢ */
#define BUFSIZE 10000L  /* ࠧ   楫 */
#define CHARSIZE (unsigned long) sizeof(buff) /*  ᨬ. */
#define NAME_LEN 13     /*   䠩 */
#define NUMFILES 8      /* ᫮ 㥬 䠩 */
int buff[BUFSIZE];    /*   */
                      /*  䠩  */
char files[NUMFILES][NAME_LEN]={ "SRC0.DAT", "SRC1.DAT",
                                 "SRC2.DAT", "SRC3.DAT",
                                 "SRC4.DAT", "SRC5.DAT",
                                 "SRC6.DAT", "SRC7.DAT",
                                                        };
main()
{
  int j,n;               /* 稪 横 */
  long total;            /* 㬬  */
  unsigned short handle; /* 䠩   DosOpen */
  unsigned action;       /* ⢨  DosOpen */
  unsigned BytesRead;  ; /* , ⠥ DosRead */

  for(n=0, total=0; n<NUMFILES; n++) { /*  䠩*/
                         /* ⨥ 䠩 */
  DosOpen(files[n], &handle, &action, CHARSIZE,
                          ATTR, OPENFLAG, OPENMODE, 0L );
                         /* ⥭ 䠩 */
  DosRead(handle, (char far *)buff, CHARSIZE,
                                         &BytesWritten );
  DosClose(handle);      /*  䠩 */
                         /*   */
  for (j=0; j<BUFSIZE; j++) { /*   */
     total +=buff[j];         /*   饬 */
     if( buff[j] !=n )
       printf ("娥 : file %d\n", buff[j], n, j);
  }
 }
                 /* ⮡ࠦ १⮢ */
 printf("㬬   %ld\n", total);
 exit(0);
}
  exit(0);
}

     ⮩  ணࠬ   祣 .    室   䠩  
䠩,    ᫥饣  䠩   ⥭   ᯨ᪠, 뢠
files. ( ॠ쭮 ⠭ ⠪   㤮     
짮⥫   ⥭   ⤥쭮 䠩).   ⮨ 
  ⥩.     ࢮ    楫    䠩  ஢, ⮡
㡥,   ⠪ ,   䠩.  ࠧ,  室
 SRC.DAT  - 䠩,   㤥  ,   䠩   n
ࠢ 3,   ࠢ  3.    -        䠩
᪫뢠   㬬 ⠥   ணࠬ. ..  
䠩 ᮤন 10000 楫, 㬬  㤥 0+10000+20000  ⠪   70000,
 饩 㬬  280000.  ᬮ  ⮣ ⠥ ᫠  ஢,
 ணࠬ ⠫  ஠஢   筮.

      ᬮਬ,     ᪮  ࠡ  ணࠬ,   ᯮ
筮.          楯窨     ਬ   
믮騥  ६.         楯窠  ⠥,   㣠
. ஡   ⮬,  ⮡ ᪮न஢   ࠡ  ⠪,
⮡    믮﫠  ਥ  ६.     ஡㥬  4 ࠧ
室:     ᮣᮢ,  ᯮ짮  ⮣  ᥬ   
ᮣᮢ  ⥭,  ᯮ짮  ᨭ஭  ⥭   
DosReadAsync(),  ᯮ짮 DosMuxSemWait().

          ਧ.

     ⥭    䠩     㣮  
  ६,  ॡ          .   ᫨   㤥
ᯮ짮 ⢥ ,   㤥 
ࠡ    묨,        祭  ,  ..
         . 襭  -  ᯮ짮
  (  ᪮쪮)  ஢.  砫     
᪠,   ६ 㣮 .  ⥬ ஫ ஢ ,
      稭  ࠡ    ஬,  ⮫쪮  
   묨,         ९뢠   ⮫쪮   
஠஢ .
    ᯮ짮  ஢    ᠭ  ⮩ .

                    

       믮   楯窨 ६   ⥭ 
 䠩  न樨 楯祪.   楯窠 , 
䠩     ࠡ,     ᯮ  ⤥   ,  ࠡ   
த    ⠪     .            
ᨭ஭஢, ⥭     ᮣᮢ, ⠪   
楯窨    ६      ६.   
⥫⢠ ணࠬ  㤥 믮,  ..   楯窨 
ᯮ짮    ६,    樮  ⥬  
  ६  㯠    ᪮쪨  ࠧ 䠩.
   䥪⨢    㢥稢    ਬ    ⥭ᨢ
୮       ६   ⥭     ᪠,  ⠪,    ⮡
ᮣᮢ 楯祪  﫠  ᪮.

                                   

    ᯮ  1  ᥬ,        㢥७,   楯窠
⠥ 䠩,  㣠 .  ਢ ਬ 
  楯祪 ⠥      .

      楯窠  ⢥砥    ᢮  . 窠 0 ⠥ 䠩
0,2,4  6   0,  楯窠 ⠥ 䠩 1,3,5,7   1.

    ..    楯窨      ⢨  (   ࠧ
),      ᯮ짮       .  㦥
 ਬ ⮣   ணࠬ horsrace.c    5.   
ணࠬ ᪠ 楯窨,  頥 ࠬ 0  1 -  楯 
ࠬ 1  2 - , ᯮ ⥪,  ᠭ   5.

/* semdata.c */
/*   ᪮ 䠩 */
/* ᯮ ࠧ 楯窨    */
/*  (ᮢ )   */
#define INCL_DOS
#include <os2.h>
#include <malloc.h>      /*  malloc() */
#define STACK_SIZE 512   /* ࠧ ⥪   楯窨*/
#define ATTR 0           /* ଠ 䠩 */
#define OPENFLAG 0x01    /* ᡮ, ᫨ 䠩 , 
                               */
#define OPENMODE 0x0040 /* =-  ᮢ= ⮢ */
#define BUFSIZE 10000L  /* ࠧ   楫 */
#define CHARSIZE (unsigned long) sizeof(buff) /*  ᨬ. */
#define NAME_LEN 13     /*   䠩 */
#define NUMFILES 8      /* ᫮ 㥬 䠩 */
#define WAIT -1L        /*  ᥬ 筮 */
unsigned long total;    /* 㬬  */
int buff[2][BUFSIZE];   /*    */
unsigned long ReadSem=0; /* ࠢ 㯮   */
                        /*  䠩  */
char files[NUMFILES][NAME_LEN]={ "SRC0.DAT", "SRC1.DAT",
                                 "SRC2.DAT", "SRC3.DAT",
                                 "SRC4.DAT", "SRC5.DAT",
                                 "SRC6.DAT", "SRC7.DAT",
                                                        };
main() /*  ⤥ 楯祪 buff[0]  buff[1] */
{
 int far *stkptr;   /*   int  args */
 void far dobuff(); /* । 楯窨 */
 unsigned thrdID;   /* ࠭⢮   ID 楯窨 */
 int j;             /* 稪 横   楯祪 */
                    /*   楯祪 */
 for (j=0; j<2; j++); {
    stkprt = (int far *)malloc(STACK_SIZE) + STACK_SIZE;
    *--stkptr = j; /* ।   */
                   /* 砫  楯窨 */
    DosCreateThread(dobuff,&thrID,(char far *)stkptr);
 }
 DosExit(0,0);  /*   楯 */
}

/* dobuff() */
/* 楯窠 ⥭    */
/* ᯮ짮     ਠ権 楯窨 */
void far dobuff(buffdex)
int buffdex;  /* 0=buff[0], 1=buff[1] */
{
  char far *pbuff;
  unsigned short handle; /*  祢 䠩 */
  unsigned action;       /* ⢨  DosOpen */
  unsigned BytesRead;  ; /* , ⠥ DosRead */
  int n,j;               /*  横 */

  for( n=buffdex; n<NUMFILES; n+=2 ) {
                 /* ⠭ ptr  砫  */
    pbuff = (char far *)buff[buffdex];
                 /*  ⥭ ᥬ */
    DosSemRequest( &ReadSem, WAIT );
                 /*  䠩 */
    DosOpen(files[n],&handle,&action,CHARSIZE,
                          ATTR, OPENFLAG, OPENMODE, 0L );
                 /*  䠩 */
    DosRead(handle,pbuff, CHARSIZE, &BytesRead );
    DosClose( handle ); /*  䠩  */
                        /*  ᥬ ⥭ */
    DosSemClear( &ReadSem );
                        /*   */
    for (i=0;j<BUFSIZE; j++) { /*   */
      total += *((int far *)pbuff + j);
      if( *((int far *)pbuff+j) !=n)
         printf("娥 =file %d\n", n);
    }
  }
  if( buffdex==0 )   /* ᫨ ᫥ 䠩  buff[0] */
    DosExit(0,0);    /*   ⮩ 楯窨 */
  else {             /* ᫨ ᫥ 䠩  buff[1] */
 printf("㬬   %ld\n", total);
  exit(0);           /*   楯窨 */
  }
}


     ⠭  2 - ୮ ᨢ,  㯭 १ 
-    0    1,    ।  楯窥  ࠬ.  
ࠬ  ᯮ  ⠪    砫쭮  祭  ६
横  n  -      楯窥  n      ⠥ 䠩
(0,2,4,6  楯窨 0; 1,3,5,7  楯窨 1).

     ᯮ㥬 ᥬ ReadSem   न樨 㯠   , 
DosSemRequest()  DosSemClear()   ᯥ祭 ᮢ⭮  㯠,
 ᠭ    6.  ᯥ稢 न,  室 
ୠ⨢ ⥭  .

     楯窠 ⠥   ᢮ 4 䠩.   ,
楯窠 0 蠥  ᥡ. 窠 1  ⠥ १   蠥
ணࠬ.

    .9-1 뢠    楯窠  ᥬ஬  ଥ
६ ࠬ. ,   楯窠 ⢥砥  ⥭  
  ᢮ ᮡ⢥ .

       Ŀ  
. 0 ⥭       ⥭         ⥭
         
       .      .              .      .               .
       .    .             .     .              .
       .    .             .     .              .
       .    .             .     .              .
       .    .  
. 1 .    .  ⥭         ⥭   
       .      .  
       .    .  .    .   .     .   .    .   .
       .    .  .    .   .     .   .    .   .
       .    .  .    .   .     .   .    .   .
       .    .  .      .   .     .   .      .   .
       .    .  .    .   .     .   .    .   .
       .    .  .    .   .     .   .    .   .
       Ŀ  Ŀ    Ŀ   Ŀ    
                                      
                                

        .9-1. ६ ࠬ semdata.c


    ⨬,    ⥭      ந室  ६  
  㣮.    ࠧ,    楯窠  稭 , 
⠭  ᥬ.  ᫥  ⥭      ,   㣠
楯窠 稭  ⥭. ᫨   楯窠,  । 0, 
  ⮣,  楯窠 1  ⥭, 楯窠 0  ,
 楯窠  1    ᪮,  । ⥬,    ᬮ 
⥭ ᫥饣 䠩.

     ⠪ 室   襭  浪   ⥭.
  ,  ਬ,     楯窠  0   ,  ⠥   
 䠩 0  2 ।  ⥬,  楯窠 1    
६    ⠥  䠩  1.    ⮬  ਬ  祣 譮 
ந室, ..   冷  ⥭   䠩.   , 
 , 室 㣨 , ᬮ७  2  .

                            

     ᪮  २⢠       筮
樨    襩  ணࠬ     ?   ᪨   
⨬쭮  樨  ᪮  ணࠬ      㤢.  
।  ⥭      筮      ஬⮪   ६,
ਬ, 50 ᥪ㭤  ⥭  50 ᥪ㭤  .   ⮬
砥  楯窠      ६  ᫥ 襭 , 
᢮  ᪮  ன⢠.  ,  ᫨  ६  ⥭ 
 ᨫ쭮 ⫨砥,  ६     訬.
ਬ,  ᫨  ⥭  ᪠    1 ᥪ㭤,   100
ᥪ㭤, 筮  㢥 ᪮ ணࠬ ⮫쪮
 1 業.

    㤥   ⥭      ਡ⥫쭮      
६,    䠪஢, ⠪,  ࠧ 䠩, ᪮
᪠,  ਧ        ᪮,  ᪮   鸞
㣨  ᮢ,        ᯮ짮 ஬ 
ࠩ஬ ६. ணࠬ  ࠢ ⮫쪮  묨
  䠪஢.

    㣮 䠪 - ,   ᮢ६  ⥬  
ࠥ 横    祭 ⥭  .  ᫮  ⠪
"ࠤ" 横  㭪   ᪮ ᪠    ᮡ⥩
䨣樨  .    ᫨  ६  ⥭    ࠢ,
⮯業⭮ ॢ室⢮   ᯮᮡ , ..
६     ॢ蠥  ࠤ   横     ⥭.   
   饣   ᯮ짮   ⤥   ஢   
ࠧ쭮  ⥫쭮  ,  ⠪,      -  뢮, 
ਡ  ᮮ⭮襭    ⨬쭮.     ᯮ짮
  設    ⨣    祬 30 -  業⭮
㢥祭 ᪮.

                       -     

      ᬮਬ  㣮  室    믮  ६
᪮  ⥭.    室   ᯮ    API  㭪   -
DosReadAsync().    ⮩  㭪樨  祭  宦     DosRead().
稥  ⮬,   頥,  ⮫쪮 砫 ⥭,  
⮣,    訫,     㭪 DosRead().  
砥,    楯窠,  ᫠  맮 DosReadAsync(),  ᫥
⮣    㣨  .    樨  襭   ⥭
DosReadAsync()   ᥬ.   窠 ⮣     ᥬ,
믮  㣮  ⥭       .  訢 ணࠬ
⠭ ᥬ । 맮 㭪樨.


         DosReadAsync() - ᨭ஭ ⥭  䠩
Ŀ
DosReadAsync(Handle,ASem,ARetCode,Buff,Bufflen,ABytesRead);       
unsigned short Handle;   /* 䠩  */                     
unsigned long far *ASem; /*  ᥬ  */                 
unsigned far *ARetCode;  /*    */                
void far *Buff;          /* 室  */                     
unsigned BuffLen;        /* ᫮ ⮢  ⥭ */            
unsigned far *ABytesRead;/*  ⠭ ⮢ */             

    DosReadAsync()   ᯮ   6   㬥⮢.   ࠬ  Handle,
Buff,BuffLen  ABytesRead 室  묨  DosRead().  ࠬ
ASem -   ᥬ  ,   㭪   ᫥ 襭
⥭. ARetCode -  ᫮, 㤠 ⥬ 頥 訡 ⥭.

    騩 ਬ 믮    8  -  䠩  
  semdata.c.    ..    ਬ  DosReadAsync(),  
室 ᯮ짮  ᪮쪮 楯祪.    稭  ⥭ 
   ।饣 ⥭ (᫨  )  ⥬  
ᥬ । 砫  ᫥饣 ⥭. ᯮ  2 ,   
࠭, 饭 ᮡ⢥묨 ᥬࠬ.

/* syncdata.c */
/* ⥭   䠩    ६ */
/* ᯮ DosReadAsync() */
/*  (ᮢ )   */
#define INCL_DOS
#include <os2.h>
#define BUFSIZE 10000L  /* ࠧ   楫 */
#define CHARSIZE (unsigned long) sizeof(buff) /*   */
#define NUMFILES 8      /* ᫮ 㥬 䠩 */
#define NAME_LEN 13     /*   䠩 */
#define ATTR 0           /* ଠ 䠩 */
#define OPENFLAG 0x01    /* ᡮ, ᫨ 䠩 , 
                               */
#define OPENMODE 0x0040 /* =-  ᮢ= ⮢ */
#define WAIT -1L        /*  ᥬ 筮 */
unsigned long total;    /* 㬬  */

int buff[2][BUFSIZE];   /*    */
unsigned long Sem=[2];  /*  ᥬ  */
                        /*  䠩  */
char files[NUMFILES][NAME_LEN]={ "SRC0.DAT", "SRC1.DAT",
                                 "SRC2.DAT", "SRC3.DAT",
                                 "SRC4.DAT", "SRC5.DAT",
                                 "SRC6.DAT", "SRC7.DAT",
                                                        };
main()
{
 unsigned short handle; /* 䠩  */
 unsigned action;       /* ⢨  */
 unsigned BytesRead;    /* ⠭  */
 int toggle;            /* 롮 buff0  buff1 */
 int n,j;               /* 稪 横 */
 unsigned lond total;   /* 㬬   */
 unsigned rcAsync;      /*    ᨭ. ⥭ */

 sem[0] = 0;            /*  ᥬ */
 sem[1] = 0;
 toggle = 0;            /* 砫 buff[0] */
             /*   ⠥ 䠩 */
 for(n=0; n<= NUMFILES; n++0)  {
   if (n!=NUMFILES) { /*  ᫥ 横 */
                      /*  䠩 n */
   DosOpen(files[n], &handle, &action, CHARSIZE,
                     ATTR, OPENFLAG, OPENMODE, 0L );
                      /* ⠭ ᥬ */
   DosSemSet( &sem[toggle]);
                      /* 砫 ⥭   */
   DosReadAsync( handle, &sem[toggle], &rcAsync,
                  buff[toggle], CHARSIZE, &BytesRead );
   } /*  if */
                 /* ४祭 */
   toggle = toggle? 0:1;
   if(n!=0) { /*  ࢮ 横 */
              /*  "᢮" ᥬ */
   DosSemWait ( &sem[toggle], WAIT);
              /*  "㣮"  */

    for (i=0;j<BUFSIZE; j++) {
      total += buff[toggle][j];
      if( buff[toggle][j] !=n-1)
         printf("娥 =file %d char %d\n", n-1,j);
    }
  } /*  if */
 } /*  横 */
            /*  १⮢ */
 printf("㬬   %lu\n", total);
  exit(0);
  }
}


    ⨬,       ࠧ   ணࠬ        
।饣  ⥭    横.   ६  toggle  ᯮ  
࠭   ᯮ㥬  . ਬ, ணࠬ ⠥  
  ,  ⥬  ४砥  ६   㣮 , 
ᮤন 䠩, ⠭ ।騬.

     ⠥ 1 -  䠩 (SRC.DAT)   ।饣  n=0,
  ணࠬ ய᪠. ,  
᫥ 䠩,  ᫥饣  䠩  ⥭, n  ⠭ ࠢ
  䠩,    ய᪠      ணࠬ.   .9-2
뢠    -  奬  ⢨  ணࠬ,   .9-3 뢠
६ ࠬ.

   Ŀ
   砫
      Ŀ                         Ŀ
       V                  Ŀ                V
   Ŀ    VĿ    VĿ        Ŀ
   ⥭     ⥭     ⥭         ⥭ 
   䠩 0    䠩 0    䠩 0         䠩 0
                        
      0          0          0               0   
                    
                                                
       V            V            V                 V
   Ŀ    Ŀ    Ŀ         Ŀ
   ⥭     ⥭     ⥭          ⥭ 
   䠩 0    䠩 0    䠩 0  ^      䠩 0
                       
      0          0          0              0   
                   
                          VĿ
                                                  
                                                  
         .9-2.  - 奬 syncdata.c


         ..0       ..2
          ..1              ..3
        V V             V         V
        
窠                               
        
        .      .          .         .         .
       Ŀ          Ŀ  .         
        .0            .2   .         
                   .         
  OS Ĵ . Ŀ        .      .  Ŀ  .
       .  .1         .      .   .3   .
       .         .      .    .
        Ŀ .        Ŀ  .      .  >
          .     .                .      .  
.0     .          
          Ŀ                  Ŀ
                                        
.1               >

         .9-3. ६ ࠬ syncdata.c


    㭪    ,     DosWriteAsync(),    ࠡ⠥     筮
DosReadAsync().  砢    ,    頥  ࠢ
ணࠬ,    ⥬  த      䠩.    
祭, 㭪  ᥬ.

         DosWriteAsync() - ᨭ஭   䠩
Ŀ
DosWriteAsync(Handle,ASem,ARetCode,Buff,Bufflen,ABytesWrit); 
unsigned short Handle;   /* 䠩  */                
unsigned long far *ASem; /*  ᥬ  */            
unsigned far *ARetCode;  /*    */           
void far *Buff;          /* 室  */                
unsigned BuffLen;        /* ᫮ ⮢  ⥭ */       
unsigned far *ABytesWrit;/*  ᠭ ⮢ */       

    ࠬ, ᯮ㥬  㭪樥, 室   DosReadAsync().  ᫨
᫮  ,  ஥      㪠   㬥 ABytesWrit, 
ᮮ⢥ ॡ㥬  BuffLen,   ९.

     ᯮ짮 DosReadAsync()  DosWriteAsync() ,  
  뢠  䠩    ᫥  맮  㭪樨, ..  
ࢥ    -  뢮.   㭪   믮,   
  ᥬ,    䠩    ஬    믮  
樨.

         न   DosMuxSemWait()

     ணࠬ semdata.c  楯窠 ⢥砥  ᢮ , 
䠩     .  ᫥騩 ਬ ⠪ ᯮ 2
楯窨,   ⢥⢥ ࠧ .     楯窠
ᯥ樠    ⥭,    㣠  -    .  楯窠
।   ࠬ:   楯窠   0
묨,    楯窠     1; ⥬  
  ࠬ,      楯窠      1,   
 ࠡ⠥  ஬ 0.

      न樨  権    -  뢮    ⮩ ணࠬ 
ᯮ짮 㭪  DosMuxSemWait(), ᬮ७     5.  
㭪   楯窥   ⪨      ( )
ᥬ஢.  襩 ணࠬ   楯窠 ᯮ   㭪
 ,      ஢ ,    ६ 
    .

    室    ⠭    ᯨ᮪    ᥬ஢,    ॡ㥬
DosMuxSemWait()    ⨭  ᪮쪮 ,     ࠡ
ணࠬ    ᫮, 祬 semdata.c   syncdata.c.   
ணࠬ ᪠ ⤥ 楯    ,   뢠
㭪  ᮮ⢥饩 楯窮  믮 ᪮ ⥭.

    ᯮ 4 ᥬ,  2   . E0  E1 
饩  楯窮    樨,       0       1
ᮮ⢥⢥  ().  楯窠  
 ᥬ । 饭   ᪠  .  F0  F1
 饩 楯窮  樨,     묨.
  楯窠      ᥬ  । 砫 
.

    ⨬,       ᥬ   뢠  砫    ᮡ
ﭨ. ⪠ ᥬ full 뢠,   , ⪠
ᥬ  empty  뢠,      .     
⨢騬    ࠡ,      ᥬ  API - 㭪樨 
⪨,   ⠭ ᥬ.

/*paradata.c */
/*   ᪮ 䠩 */
/* ᯮ ࠧ 楯窨  ⥭   */
#define INCL_DOS
#include <os2.h>
#include <malloc.h>      /*  malloc() */
#define STACK_SIZE 512   /* ࠧ ⥪   楯窨*/
#define ATTR 0           /* ଠ 䠩 */
#define OPENFLAG 0x01    /* ᡮ, ᫨ 䠩 , 
                               */
#define OPENMODE 0x0040 /* =-  ᮢ= ⮢ */
#define BUFSIZE 10000L  /* ࠧ   楫 */
#define CHARSIZE (unsigned long) sizeof(buff) /*  ᨬ. */
#define NAME_LEN 13     /*   䠩 */
#define NUMFILES 8      /* ᫮ 㥬 䠩 */

int buff0[BUFSIZE];     /*    */
int buff1[BUFSIZE];     /* ன   */
unsigned long E0=0L;    /* 騥 ᥬ */
unsigned long E1=1L;
unsigned long E0=0L;    /* 騥 ᥬ */
unsigned long E1=1L;

struct MuxList {       /*  DosMuxSemWait */
  unsigned SemCount;   /* ᫮ ᥬ஢ */
  unsigned res1;       /* १.,   0 */
  void far *ps1;       /* 㪠⥫  ᥬ 1 */
  unsigned res2;       /* १.,   0 */
  void far *ps2;       /* 㪠⥫  ᥬ 2 */
}
                       /*  䠩  */
char files[NUMFILES][NAME_LEN]={ "SRC0.DAT", "SRC1.DAT",
                                 "SRC2.DAT", "SRC3.DAT",
                                 "SRC4.DAT", "SRC5.DAT",
                                 "SRC6.DAT", "SRC7.DAT",
                                                        };
main() /*  饩  饩 楯祪 */
{
 char far *stkptr; /* ⥪ 㪠⥫   楯 */
 void far analyse();/* ।  楯窨 */
 void read();       /* । 㭪樨 ⥭ */
 unsigned threadID; /*  楯窨 ID */
 unsigned rc;       /*   */

 DosSemSet(&F0);  /* ⠭  ᥬ஢ */
 DosSemSet(&F0);

                  /* 砫 楯窨   */
 stkprt = (int far *)malloc(STACK_SIZE) + STACK_SIZE;
 DosCreateThread(analyse, &threadID, stkptr);
 read();         /* 맮 ணࠬ  ⥭  */
                 /*    ⥭ */

/* read() */
/* ⥭   䠩  뢮 १⮢ 
                                 buff0  buff1    */
void read()
{
  struct MuxList list;   /*   DosMuxSemWait */
  unsigned index;        /*    ᥬ஢ */
  char far *pbuff;       /* 㪠⥫   */
  unsigned short handle; /*   祢 䠩 */
  unsigned action;       /* ⢨ DosOpen() */
  unsigned BytesRead;    /* , ⠥ DosRead */
  int n;                 /* 稪 横 */

  list.SemCount = 2;  /* ᯨ᮪ ⥭ DosMuxSemWait() */
  list.res1 = 0;
  list.ps1 = &E0;
  list.res2 = 0;
  list.ps2 = &E1;
                 /* ⥭ 䠩  buff0  buff1 */
  for(n=0, n<NUMFILES; n++) {
                    /*  室 䠩 */
    DosOpen(files[n], &handle, &action, CHARSIZE,
                         ATTR, OPENFLAG, OPENMODE, 0L);
                    /*  ᥬ஢ E0  E1 */
    DosMuxSemWait(&index, &list, -1L);
    if(index == 0) {             /* ᫨ 뫮 ᮡ⨥ T0 */
      pbuff = (char far *)buff0; /* ᯮ짮  0*/
      DosSemSet( &E0 );          /* ⠭ E0 */
    } else {                     /*  E1 */
       pbuff = (char far *)buff1;/* ᯮ.-  1 */
      DosSemSet( &E1 );          /* ⠭ E1 */
    }
         /* ⥭ 䠩 */
      DosRead(handle, pbuff, CHARSIZE, &BytesRead );
      if( index == 0 )       /* ᫨ 뫮 ᮡ⨥ E0 */
         DosSemClear( &F0 ); /* ⪠ F0 */
      else                   /* ᫨ 뫮 ᮡ⨥ E1 */
         DosSemClear( &F0 ); /* ⪠ F1 */
      DosClose(handle);
    } /*  横 */
    DosExit(0,0);            /* 室  楯窨 */
}

/* analyze() */
/* ⤥쭠 楯窠:    buff0  buff1 */
void far analyze()
{
  struct MuxList list;   /*   DosMuxSemWait */
  unsigned index;        /*    ᥬ஢ */
  char far *pbuff;       /* 㪠⥫   */
  int rc;                /*   */
  int n,j;               /* 稪 横 */
  long total = 0;        /* 㬬  */
  list.SemCount = 2;  /* ᯨ᮪ ⥭ DosMuxSemWait() */
  list.res1 = 0;
  list.ps1 = &E0;
  list.res2 = 0;
  list.ps2 = &E1;
  /*   㯭  -  䠩 */
  for(n=0, n<NUMFILES; n++) {
                    /*  ᥬ஢ F0  F1 */
    DosMuxSemWait(&index, &list, -1L);
    if(index == 0) {             /* ᫨ 뫮 ᮡ⨥ T0 */
      pbuff = (char far *)buff0; /* ᯮ짮  0*/
      DosSemSet( &E0 );          /* ⠭ E0 */
    } else {                     /*  E1 */
       pbuff = (char far *)buff1;/* ᯮ.-  1 */
      DosSemSet( &E1 );          /* ⠭ E1 */
    }

    for (n=0;j<BUFSIZE; j++) { /*   */
      total += *((int far *)pbuff + j);
      if( *((int far *)pbuff+j) !=n)
         printf("娥 =file %d\n", n);
    }
  }
    if(index == 0) {             /* ᫨ 뫮 ᮡ⨥ T0 */
      DosSemClear( &E0 );        /* ⪠ E0 */
      else                       /*  E1 */
      DosSemClear( &E1 );        /* ⪠ E1 */
 } /*  横 */
          /* 뢮 १⮢ */
 printf("㬬   %ld\n", total);
  exit(0);           /*   楯窨 */
}


     楯窠 뢠 䠩, ⥬   ᥬ஢ - E0 
E1. 砫쭮   ᥬ  饭,   ⥭ 稭  .
᫥   ஢  ணࠬ ,    
㣮    ஠.  ।    , 
楯窠 ⠭  E0   E1, ⠪   ⥭   㤥    
ᠬ ,     ᮤন   ஠.   ⥭
祭,      楯窠      F0      F1,   ᨣ
饩,     ⮢ ஢.

     楯窠  F0  F1. 砫쭮    ᥬ
⠭,    ᥬ     饩 楯窮, 
.   ⮫쪮    ᥬ஢  ⨫,   楯窠
⠭  F0    F1     ,           㤥
஢  ᫥饣 .   ஠஢,
F0  F1  頥, 뢠,    ⮩    楯窠
  . .9-4 뢠  - 奬 ணࠬ.

                                      

     ணࠬ   ,  ᠭ ,  冷,  ஬
  䠩,    .  ,    ᫥騩  ਬ -
ணࠬ,      ᯮ   筮     ⮡ࠦ
ᮤঠ  ⥪⮢  䠩.    ⠥  ⮫쪮    䠩, 
冷,  ஬  䠩 ⠥   ⮡ࠦ - 堮祭.  
室  ⢨   TYPE  DOS.  짮⥫ ଫ  
䠩  㬥  ப.

     ⥭    ᪮    ணࠬ  ᯥ稢
33 - 業⭮   㢥祭   ᪮      ࠢ      筮
筮  ணࠬ.    ᯮ짮 筮 室
ᯫ ন,   ⠥  .      ࠭
筮, ..   ⥭ 믮 ६
 ᯫ.  祭 ᪮    䠪஢   
⭮   ᪮ ன⢠.

                  Ŀ
                    ⠭ F0  F1  
          
     楯窠                V
 Ŀ        Ŀ
       V        V                      
  Ŀ                  楯窠
      䠩                  
                           Ŀ
             V                       V           V       
  Ŀ    Ŀ   
      E0  E1            E0  E1       
         
        V          V               V           V         
  ĿĿ    ĿĿ   
  . .0. .0    . .0. .0   
         
        V          V               V           V         
  ĿĿ    ĿĿ   
  ⠭ E0⠭ E1    ⠭ E0⠭ E1   
         
        V          V               V           V         
  Ŀ    Ŀ   
  ⥭ 䠩           ॳ   
         
        V          V               V           V         
  ĿĿ    ĿĿ   
  ⪠ F0 ⪠ F1     ⪠ F0 ⪠ F1    
         
        V          V                                   
     Ŀ                                 
       䠩                                   
                           
             V                             V          
  Ŀ    Ŀ  
 Ĵ 䠩 ࠡ⠭?     䠩 ࠡ⠭?
          
                 V                        V 
            Ŀ                Ŀ
                            
                                        
            楯                  楯  
                            


        .9-4.  - 奬 paradata.c


       ।饩 ணࠬ,     .   
ணࠬ    readisp.c  ᪠  2  楯窨,  reader()  display().
窠 reader()  ⠥ ᪮  䠩 ६   2  , 
display() ६  ᮤন   ࠭.

       paradata.c   4 ᥬ,   2     .  
   ᥬ஢ ࣠  ᨢ:  FullSem[0]  
FullSem[1]  ,      ᮮ⢥騥  , 
EmptySem[0]  EmptySem[1] ,    .

     ணࠬ  襭 , ⥬ ⠥ 
 .  ⮫쪮  ⥭ 訫, ணࠬ   ᥬ full
⠪,         뢮.  ᯫ  ணࠬ   
 , ⥬  뢮    ࠭.    ⮫쪮 
뢮,     ᥬ     쭥襣      饩
ணࠬ.

/* readisp.c */
/* ⥭ ⥪  ᪮ 䠩  ⮡ࠦ  */
/* ᯮ ࠧ 楯窨  ⥭  ⮡ࠦ*/
#define INCL_DOS
#define INCL_SUB
#include <os2.h>
#include <malloc.h>      /*  malloc() */
#define STACK_SIZE 512   /* ࠧ ⥪   楯窨*/
#define ATTR 0           /* ଠ 䠩 */
#define OPENFLAG 0x01    /* ᡮ, ᫨ 䠩 , 
                               */
#define OPENMODE 0x0040 /* =-  ᮢ= ⮢ */
#define BUFSIZE 512L    /* ࠧ    */
#define WAIT -1L        /*  ᥬ 筮 */
#define HANDLE 0        /* ᥣ 0 */
int buff[2][BUFSIZE];   /*    */
                        /* ⪠  砭 ⥭ */
unsigned long FullSem[2] = { 0, 0 };
                      /* ⪠  砭 ⮡ࠦ */
unsigned long EmptySem[2] = { 0, 0 };
unsigned short handle; /*  室 䠩 */
unsigned action;       /* ⢨  DosOpen */
unsigned BytesRead; /* ⠭ ⮢ (  ஢) */

main(argc,argv)  /*   楯祪 */
int argc;
char *argv[];
{
 int far *stkptr;  /* ⥪ 㪠⥫ */
 void far reader(); /*  饩 楯窨 */
 void far display(); /*  ⮡ࠦ饩 楯窨 */
 unsigned thrID;   /* ࠭⢮   楯窨 ID */
 if(argc !=2)
   { printf("Syntax: readisp filename"); exit(1);

 DosSemSet(&FullSem[0]); /*  砫쭮  */
 DosSemSet(&FullSem[1]);
                 /*  䠩 */
 DosOpen(files[n], &handle, &action, CHARSIZE,
                      ATTR, OPENFLAG, OPENMODE, 0L);

                 /*  饩 楯窨 */
    stkptr = (int far *)malloc(STACK_SIZE) + STACK_SIZE;
    DosCreateThread(reader,&thrID,stkptr);

                 /*  饩 楯窨 */
    stkptr = (int far *)malloc(STACK_SIZE) + STACK_SIZE;
    DosCreateThread(display,&thrID,stkptr);

    DosExit(0,0);  /*   楯 */
}

/* reader() */
/* 楯窠 ୠ⨢ ⥭  ஢ */
void far reader()
{
  int toggle = 1; /* 0=buff[0], 1=buff[1] */
  do {            /* ४祭  㣮  */
   toggle = (toggle) ? 0:1;
         /* ,  ᯫ ⠥  */
   DosSemRequest( &EmptySem{toggle], WAIT);
         /*   䠩 */
   DosRead(handle, buff[toggle], BUFSIZE,
                                  &BytesRead[toggle]);
         /* ⬥ -   -  display() */
   DosSemClear( &FullSem[toggle]);
         /* EOF ( 䠩)     */
  } while( BytesRead[tjggle] == BUFSIZE );
  DosClose( handle ); /*  䠩 */
  DosExit(0,0); /*   楯 */
}

/* display */
/* 楯窠 ୠ⨢ ⮡ࠦ  ஢ */
void far display()
{
  int toggle = 1; /* 0=buff[0], 1=buff[1] */
  unsigned bytes; /*  稪 ⮢ */
  do {            /* ४祭  㣮  */
   toggle = (toggle) ? 0:1;
         /* ,    */
   DosSemRequest( &FullSem{toggle], WAIT);
         /* ࠭   ᫥饣 ⥭ */
   bytes = BytesRead[toggle]);
         /* ⮡ࠦ  */
   VioWrtTTy( buff[toggle], bytes, HANDLE );
         /* ⬥ -   -  ⥭ */
   DosSemClear( &FullSem[toggle]);
         /* 室,   ᫥  */
  } while( bytes == BUFSIZE );
  DosClose( handle ); /*  䠩 */
  exit(0); /*   楯窨 */
}


        syncdata.c,  toggle  ᯮ    ४祭 
ࠬ. ,  ⠪  ᯮࢠ ⤥ ᥬ஢ full  empty
    ,  ন    ⥭    ⮡ࠦ 
室 浪.  室 ⠪  ᯮ짮   ࠧ
६,          ,      ⢨⥫쭮
⠭  ᫠  ⮢.   (  祭     , 祬
ࠧ    ᫥  ⥭).  ᯮ짮     ࠧ
६     ।  祭     饩   楯窨  
⮡ࠦ饩.   ᯫ  楯窠    ࠭   祭 
쭮 ६;        楯窠   ⥭
᫥饣  .    ६  ।⠢   ᨢ  
⮢. .9-5 뢠  - 奬 ணࠬ.

           Ŀ
       楯窠      ⠭ FullSems 
                  
                            V
                  Ŀ
                     䠩        
                  
                            V
                  Ŀ
            - - Ĵ  楯窨       
           .           .
           .                V                  .
           .      Ŀ     .
           .         楯        .
           .           .
   .                                   . ⮡ࠦ
  楯窠  V                                   V   楯窠
   Ŀ                  Ŀ
    toggle = 1                        toggle = 1   
                     
 Ŀ                                        Ŀ
      V      V                            V      V       
  Ŀ    Ŀ   
        Flip toggle                Flip toggle       
         
             V                            V              
  Ŀ    Ŀ   
      EmptySem             FullSem         
         
             V                            V              
  Ŀ    Ŀ   
  ⥭ 䠩         ⮡ࠦ       
         
             V                            V              
  Ŀ    Ŀ   
      FullSem            EmptySem      
         
             V                             V          
  Ŀ            Ŀ  
 Ĵ   䠩 ⮢?                  䠩 ⮢?   
                  
                 V                        V 
            Ŀ                Ŀ
                              
              䠩                   ணࠬ
                            
                 V
            Ŀ
            
            楯  
            

         .9-4.  - 奬 readisp.c


    ᫨ ⥭    室 , 祬 ⮡ࠦ 㣮,
 楯窨  砭  ⥭. ᫨ ⮡ࠦ 室  ,
祬  ⥭,     楯窨     襭   ⮡ࠦ.  .9-6
뢠  ⢨  ६ ࠬ.

              - - - - -
reader()     buff0   buff1      buff0       buff1
              - - - - -

             - - - - - Ŀ - - - 
display()         buff0      buff1   buff0
             - - - - -  - - - 

            Ŀ  Ŀ        
FullSem[0]                                     
                                     

            Ŀ   
FullSem[0]                           
                                  

             Ŀ   
EmptySem[0]                     
                         

                    Ŀ  
EmptySem[1]                                        
                                      


         .9-6. ६ ࠬ syncdata.c


                          

     ᬮ५  ᪮쪮 ࠧ  ᯮᮡ 筮  
᪮७ ⥭ ᪠.    室     樨,
      䠪஢.    ॠ  ᮢ    
ᯥਬ.   ன,  ன 筮 믮 
ணࠬ, ஡ ᪮쪮 ࠧ 室  ᬮ,  
   襥 㢥祭  ᪮   ࠢ  
⮤.        㢥祭  ᪮  ࠢ뢠
⥫쭮 ᫮.        ⨣
⥫쭮 २⢮.


             

        襯ਢ ਬ, ⥬  ९
⥭  ᪮  䠩  ࠧ묨  楯窠.     ⠪ 
ࠧ 楯祪  ६       .  .. 
楯窨      室 ,  ⥬ ।, 
 楯窨   ࠢ  ࠢ      ⮬ 䠩.  
ࠧ, न஢   䠩 ᪮쪨 楯窠 -  
ணࠬ.

     ᪮쪮 ⫨砥,   ࠧ  (  
楯窨)       䠩 ६.  
⠭ 묨  ࠧ ᯥ  ᠬ 䠩,  ⠪,  ०
ᮢ⭮  ० 㯠.

    祬  ࠧ    㦤    ६ 㯥 
䠩?  ।,  짮⥫  ⨫    ࠧ ணࠬ
ࠡ⪨  ᫮.  ணࠬ  ᯮ  砫  䠩  ⠭
ࠧ  ࠬ஢,      ணࠬ  室    䠩,
  ६.    ।,    ணࠬ
ꥤ  ஭  ⠡    ⥪⮢  .   ,
⥪⮢  室  䠩  뢮    
쬠,  ஭  ⠡ ⠥ 䠩   ࠡ .  
 ᪮न஢ ⠪ ⥫쭮?

                              

     ⠥  ᮢ,     
    ⮬  䠩.   , prw.c,  ᮧ ୨ 
뢠 䠩 FILE.TXT.          
  䠩,  ਬ wfile.c  ᫥ .

       ணࠬ,   chrw.c,   ᪮쪮   ন,  
த⥫᪨        䠩.      ୨  
⠥  䠩,    㤠  - த⥫᪨   
䠩  祭  " ᥬ"    ⮢ SharingMode.   ୨
⠥  横,   䠩  짮⥫  
  த⥫᪨  ,  prw.c,        横  ᨣ,
뢠,   ⠥  䠩.

      짮⥫    ""    砫  ⥪⮢   ப,
⬥,      祭,  த⥫᪨    뢠 䠩.
୨ ⥯     䠩,   ⠭  ୨
  ⠥  ᮤন  䠩.    ⮬  ਬ த⥫᪨ 
୨         䠩 ६,  
᪫騩 .

/* prw.c */
/*   , ⥬  楯窠 ⠥  ᪠  */
/* ⠥ , 祭                 */
#define INCL_DOS
#include <os2.h>
#include <string.h>      /*  strcat()  . */
#define ATTR 0           /* ଠ 䠩 */
#define OPENFLAG 0x12    /* 祭 ண  ᮧ
                              䠩 */
#define OPENMODE 0x4012 /* =/  ᮢ= ᥬ */
#define NOPTR (char far *)0L /* 㪠⥫  0 */
#define OBLEN 32   /*    ꥪ */
#define ASYNCH 1   /*  楯窠 ᨭ஭ */

main()
{
  char string[80];       /*   ⥪    */
  unsigned short handle; /* 䠩   DosOpen */
  unsigned action;       /* ⢨  DosOpen */
  unsigned long size=0;  /*  쭮 ࠧ 䠩*/
  unsigned length;       /*  ப   */
  unsigned BytesWritten; /* , 뢠 DosWrite */
  char objbuff[OBLEN];   /*   DosExecPgm */
  struct _RESULTCODES childID; /*   १ */
  unsigned rc;           /*   */

                 /* ᮧ  楯 */
  if( rc=DosExecPgm( objbuff, OBLEN, ASYNCH,
                      NOPTR, NOPTR, &childID, "CHRW.EXE") )
     { printf("DosExecPgm error=%u\n", rc); exit(1); }

                 /*  䠩 */
  if( rc=DosOpen("FILE.TXT", &handle, &action, size,
                          ATTR, OPENFLAG, OPENMODE, 0L );
     { printf("DosOpen error=%u\n", rc); exit(1); }
                                                  e
                 /*  ᨬ   */
  printf(" ப ⥪.\n");
  printf(" 砭  "".\n");
  do {
     gets(string);
     strcat(string, "\r\n");
     length = strlen(string);

                 /*   䠩 */
  if(rc=DosWrite(handle, string, length, &BytesWritten) )
     {printf("DosWrite error=%d\n", rc); exit(1); }
  } while(length > 2);
  printf("⥫ ⥯ ஥ 䠩  멤\n");
  DosClose(handle);
  exit(0);
}

    ୨ , chrw.c, 室   ਬ஬ rfile.c   ᫥
.  室   横  㯭 䠩  FILE.TXT. 
32  -  ERROR_SHARING_VIOLATION  頥,      
   䠩, ..  䠩 ᯮ 㣮 .

/* chrw.c */
/* ୨  prw.c */
/* ⠥ ⥪⮢ 䠩  ᪠  ⮡ࠦ  */
#define INCL_DOS
#include <os2.h>
#define ATTR 0           /* ଠ 䠩 */
#define OPENFLAG 0x01    /* 訡, ᫨  䠩, 
                             ᮧ  */
#define OPENMODE 0x4042 /* =/  ᮢ=⮢  */
#define BUFLEN 40       /* ࠧ   */
#define ERROR_SHARING_VIOLATION 32 /* 頥 DosOpen*/

main()
{
  unsigned rc;           /*   */
  char buffer[BUFLEN];   /*   ⥪ */
  unsigned short handle; /* 䠩   DosOpen */
  unsigned action;       /* ⢨  DosOpen */
  unsigned long size=0;  /*  쭮 ࠧ 䠩*/
  unsigned length;       /*  ப   */
  unsigned BytesRead;    /* , 뢠 DosRead */

  DosSleep( 2000L);   /*   䠩 த⥫ */

  printf("\n 㤥   ⪥ 
                                                䠩\n");
  do {                   /* ᨣ   䠩 */
    DosBeep( 300,20);    /* 300 , 20 .ᥪ. */
    DosSleep( 200L);     /* 200 .ᥪ. */
    rc=DosOpen("FILE.TXT",&handle,&action,size,
                                 ATTR,OPENFLAG,OPENMODE,0L);

  } while( rc == ERROR_SHARING_VIOLATION );
  if(rc)
   { printf("DosOpen error=%u\n",rc); exit(1); }
  printf("\n 뫠 䠩\n");

  do {
    if( rc=DosRead(handle, buffer, BUFLEN, &BytesRead ) )
   { printf("DosRead error=%u\n",rc); exit(1); }
    buffer[BytesRead]=0; /*  '\0'   ப */
    printf("%s", buffer); /*   */
  } while( BytesRead==BUFLEN ); /*  䠩, 
                                         */

  printf(" 뢠 䠩  室\n");
  DosClose(handle);
  exit(0);
}


     ਬ ⢨   ணࠬ,   
    䥫 "  ".  (ப  祪
뢠 㤠 ᮪   ⪮).

C>prw
 ப ⥪
 砭  ப  "".
 楯窠 㤥  ,  ⠥ 
䠩.

    ,    
     த ,
       ᠬ,
    騬  ⠭  ,
    騬 -᪨ ᯮ...
    ᮡ ⨣  
        -
    蠩   ,
       !
⥫᪨  ஥ 䠩  멤
୨  䠩
    ,    
    - - - - - - - - - - - - - - -
       !
୨  뢠 䠩  室.


     짮⥫ ⠥,   ணࠬ .   .9-7
뢠 ६  த⥫᪮  ୥ .

 - - - - - - - - - - - -
 䠩 䠩室
楯       䠩          
 - - - - - - - - - - - -
         V                  V
- - - - - -
              ⠥    .      
              䠩 ⮡ࠦ. 䠩  室
                䠩            䠩               
- - - - - -
               
                   

        .9-7. ६  prw.c  chrw.c


      ⮬  ਬ  㭪  DosOpen()  ᯮ     ।⢮
। ଠ樨  䠩     㣮.  ᮡ
- ୨  ᯮ   DosOpen()  䠩 
த⥫᪨.  ᯮ짮 DosOpen() -  ,  
᪮쪮 ᮢ  ࠡ  䠩 ⥬.

                               

      ⮫쪮    ᠭ  ਬ    뢠 䠩 
⠭ ᮢ⭮ ० "  ᥬ",   ६   㣮
  ⠫          "⥭  -  ".  
 (" ᥬ"  "⥭ - ")  ⪠, ᯥ稢
᪫騩      䠩.      㣨  樨
ᮢ⭮ ०  ० 㯠, 騥    䠩
६.

    .9-8 뢠 ᮢ  ०, ᯮ㥬  ᮬ
  䠩,  ० 㯠, ॡ㥬  ᮬ, 
 ⠥    䠩.


                    Ŀ
                        ன      
                         ० 㯠     
                    Ĵ
                     ⮫쪮 ⮫쪮⥭-
                     ⥭  
Ĵ
            ⪠  訡 訡 訡
            /                      
           Ĵ
      ⪠  ᯥ  訡 訡
                          
    -      Ĵ
 ᮢ멳 ⪠  訡 ᯥ  訡
  ०     ⥭                     
           Ĵ
            ⪠ ᯥ  ᯥ  ᯥ 
                                    


        .9-8.  ०  ० 㯠


                             

      ਬ,         ६  䠩,
ᬮਬ 砩,   த⥫᪨   ୨    䠩
६.

/* prr.c */
/* ⥭  䠩   ୥ chrr.c */
#define INCL_DOS
#include <os2.h>
#define ATTR 0           /* ଠ 䠩 */
#define OPENFLAG 0x01    /* 訡, ᫨  䠩, 
                                 */
#define OPENMODE 0x0040 /* =⥭.  ᮢ=⮢  */
#define BUFLEN 40       /*  䠩  */
#define NOPTR (char far *)0L /* 㪠⥫  0 */
#define ASYNCH 1   /*  楯窠 ᨭ஭ */

main()
{
  unsigned short handle; /* 䠩   DosOpen */
  unsigned action;       /* ⢨  DosOpen */
  unsigned long size=0;  /*  쭮 ࠧ 䠩*/
  char objbuff[BUFLEN];   /*   DosExecPgm */
  struct _RESULTCODES childID; /*   १ */
  char buffer[BUFLEN+1]; /*   䠩  */
  unsigned BytesRead;    /* , ⠥ DosRead */

                 /* ᮧ  楯 */
  DosExecPgm( objbuff,BUFLEN, ASYNCH,
                    NOPTR, NOPTR, &childID, "CHRR.EXE") )
                 /*  䠩 */
  DosOpen("FILE.TXT",&handle,&action,size,
                              ATTR,OPENFLAG,OPENMODE,0L);
  do {
    DosRead(handle, buffer, BUFLEN, &BytesRead);
    buffer[BytesRead]=0; /*  '\0'   ப */
    printf("%s", buffer); /*   */
  } while( BytesRead==BUFLEN ); /*  䠩, 
                                         */
                          /*  䠩   */
  DosClose(handle);
  exit(0);
}


    ⥫᪠  楯窠   뢠  䠩     ᮢ    ०
⠭ " ࠭祭",  ୥  䠩,  
 ⠥   த⥫.

/* chrr.c */
/* ୨  prr.c */
/* ⥭ ⥪⮢ 䠩  ᪠  ⮡ࠦ  */
#define INCL_DOS
#include <os2.h>
#define ATTR 0           /* ଠ 䠩 */
#define OPENFLAG 0x01    /* 訡, ᫨  䠩, 
                                 */
#define OPENMODE 0x0040 /* =⥭.  ᮢ=⮢  */
#define BUFLEN 40       /*  䠩  */
#define NOPTR (char far *)0L /* 㪠⥫  0 */
#define ASYNCH 1   /*  楯窠 ᨭ஭ */

main()
{
  char buffer[BUFLEN+1]; /*   䠩  */
  unsigned short handle; /* 䠩   DosOpen */
  unsigned action;       /* ⢨  DosOpen */
  unsigned long size=0;  /*  쭮 ࠧ 䠩*/
  unsigned BytesRead;    /* , ⠥ DosRead */

  DosOpen("FILE.TXT",&handle,&action,size,
                              ATTR,OPENFLAG,OPENMODE,0L);
        /* ⥭ 䠩  ⮡ࠦ  */
  do {
    DosRead(handle, buffer, BUFLEN, &BytesRead);
    buffer[BytesRead]=0; /*  '\0'   ப */
    printf("%s", buffer); /*  ப */
  } while( BytesRead==BUFLEN ); /*  䠩, 
                                         */
                          /*  䠩   */
  DosClose(handle);
  exit(0);
}


          䠩 ⮫쪮  ⥭, ⠪   䠩
  ਡ "⮫쪮 ⥭"  "⥭ ".

      ணࠬ  믮,    FILE.TXT  ᮤন ⥫쭮
⢮  ⥪,     뢮   ६訢     ࠭.   
⥫쭮,   ,         䠩
६.      ॠ쭮  樨,      ᮢ,
뢮 䠩  ࠭,   ஢ 䠩  
  㣨 樨.

                       

     㢨,     ।࠭ 㣮   㯠
  楫   䠩  ⥬          ࠭祭묨   ०
ᮢ⭮    㯠.    ।,     
⮫쪮  䠩, ࠧ  ⮫쪮   䠩.

      ⮣    OS/2  ।ᬮ७  㭪 DosFileLock(), 
  ஢  䠩. ஢  
䠩 㯭, ஢ - ,     ࠧ஢.

          䠩, ᮤঠ    .
   ,  㣮 㤥    㣮
.

    DosFileLock()  ᯮ     ஢    䠩,   
ࠧ஢    ஢ન (⪮  ஢) ஢
  㣨 ᮬ.

         DosFileLock() -   ࠧ 䠩
Ŀ
DosFileLock(Handle,UnlockRange,LockRange);            
unsigned short Handle; /* 䠩  */           
long far *UnlockRange; /* 쭮 ࠧ஢ */
long far *LockRange;   /* 쭮 ஢ */   

      㭪  ᯮ  3  㬥:  䠩  ,     
ﭨ -     ࠧ㥬 ,  㣠  㥬.
    ﭨ  ⮨      楫 - ࢠ -
ᬥ饭  䠩   ,     ﭨ   . ᫨
㪠⥫ NULL  ᯮ    UnlockRange     LockRange,
⮫ ᮮ⢥ ⥫쭮   . ﭨ   
।⠢    ࠬ.  룫廊 ⠪:

struct RANGE {
 long lFileOffset; /* 砫 㥬 ᥪ樨   */
 long lRangeLength; /*  㥬 ᥪ樨   */
};

᫨ 㣮  (  ,  ஢) ⠥  
  ஢   䠩,   ஢ (ࠧ஢)
 , 頥  33 ERROR_LOCK_VIOLATION.

     ਬ, ਢ ,  , plock.c, 뢠  㦥
騩 䠩, ⥬    ,   50 -    100  - 
. ⥬ த⥫᪨   plock.c ᪠  ୨ ,
⮬ "ᯨ" 5 ᥪ㭤  ࠧ 䠩.

    ᪮ ᫥ ᪠ ୨  chlock.c ⠥  ⮡ࠦ
砫 ஢  䠩 ( 50 ).    
 ஡,     ஢. ୨  㧭,
  ᫥    䠩    ஢,  ..  ⠥
஢   䠩.

     ⪨ 㤠,   த⥫  ࠧ஢   㪠⥫
 ,   ஢ ᯥ譠,    ⮩  
䠩. ୨ ⮣ ⠥  ⮡ࠦ  ᥪ 䠩.

/* plock.c */
/*  䠩, ᪠  chlock.c,  */
/*  ⠥ ࠧ஢ 䠩    */
#define INCL_DOS
#include <os2.h>
#define ATTR 0           /* ଠ 䠩 */
#define OPENFLAG 0x01    /* 訡, ᫨  䠩, 
                                 */
#define OPENMODE 0x4042 /* =/. ᮢ=⮢  */
#define NOPTR (char far *)0L /* 㪠⥫  0 */
#define OBLEN 32       /*    ꥪ */
#define ASYNCH 1   /*  楯窠 ᨭ஭ */

struct range {          /*   DosFileLock() */
  unsigned long offset; /* ᬥ饭  砫 䠩 */
  unsigned long length; /*  ﭨ ஢ */
};

long LockRange[] = {50,100}; /*  ﭨ 稭 */
                                /*    50     */
long UnLockRange[] = {50,100}; /*   100  */

main()
{
  unsigned short handle; /* 䠩   DosOpen */
  unsigned action;       /* ⢨  DosOpen */
  unsigned long size=0;  /*  쭮 ࠧ 䠩*/
  char objbuff[OBLEN];   /*   DosExecPgm */
  struct _RESULTCODES childID; /*   १ */

                 /*  䠩 */
  printf("⥫ 뢠 䠩\n");
  DosOpen("FILE.TXT",&handle,&action,size,
                              ATTR,OPENFLAG,OPENMODE,0L);
                 /* ஢  䠩 */
  printf("⥫  䠩\n");
  DosFileLocks(handle, NOPTR, LockRange );

                 /* ᮧ  楯 */
  printf("⥫ ᮧ \n");
  DosExecPgm( objbuff,BUFLEN, ASYNCH,
                  NOPTR, NOPTR, &childID, "CHLOCK.EXE") );
  DosSleep( 5000L );    /* প */
                        /* ࠧ஢ 䠩 */
  printf("⥫ ࠧ 䠩\n");
  DosFileLocks( handle, UnLockRange, NOPTR );
  DosSleep( 2000L );    /* প */
  printf("⥫ 뢠 䠩  室\n");
  DosClose( handle );
  exit(0);
}


      ୨  .    ⠥    䠩    ⮡ࠦ  
ᮤন    ⠪ ,    rfile.did   ⪨ ⥭ ,
஢, ஢    50 -   100 -  .

/* chlock.c */
/* ୨  plock.c */
/*  ࠧ஢ 䠩, ⥬ ⠥ ⥪  */
/*  ⮡ࠦ    */
#define INCL_DOS
#define INCL_SUB
#include <os2.h>
#define ATTR 0           /* ଠ 䠩 */
#define OPENFLAG 0x01    /* 訡, ᫨  䠩, 
                                 */
#define OPENMODE 0x4042 /* =/. ᮢ=⮢  */
#define BUFLEN 51       /* ࠧ   */
#define NOPTR (char far *)0L /* 㪠⥫  0 */
#define ERROR_LOCK_VIOLATION 33 /* ⠥ ࠧ஢*/
                                /* ஢ 䠩 */

long LockRange[2] = {50,100}; /*  ﭨ 稭 */
                                /*    50     */
long UnLockRange[2] = {50,100}; /* 100 ⮢  */

main()
{
  char buffer[BUFLEN];   /*   ⥪ */
  unsigned short handle; /* 䠩   DosOpen */
  unsigned action;       /* ⢨  DosOpen */
  unsigned long size=0;  /*  쭮 ࠧ 䠩*/
  unsigned BytesRead;    /* , 뢠 DosRead */
  unsigned rc;           /*   */

     /*  䠩,  ࠧ஢  */
  printf("⥫ 뢠 䠩\n");
  DosOpen("FILE.TXT",&handle,&action,size,
                              ATTR,OPENFLAG,OPENMODE,0L);
  printf(" ⠥ 砫 ࠧ஢
                                 䠩\n");
  DosRead(handle, buffer, BUFLEN-1, &BytesRead);
  buffer[BytesRead]=0;
  printf("%s", buffer);
                 /* ⪠ ஢ 䠩 */
  printf("\n 㤥   ⪥ 
                                                䠩\n");
  do {              /* ᨣ  ࠧ஢ 䠩 */
    DosBeep( 200,20);    /* 200 , 20 .ᥪ. */
    DosSleep( 200L);     /* 200 .ᥪ. */
  } while( rc == ERROR_LOCK_VIOLATION );
  printf("\n ୨ ஢ 䠩\n");

  do {              /* ⥭  ⮡ࠦ */
  DosRead(handle, buffer, BUFLEN, &BytesRead);
  buffer[BytesRead]=0;
  printf("%s", buffer);
  } while( BytesRead==BUFLEN );
      printf("୨ 뢠 䠩  室\n");
  DosClose( handle );/* ⨥, ᢮ ஢ */
  exit(0);  /*   楯窨 */
}


    ந室,    䠩  FILE.TXT,     ࠡ 
, ᮤন 뤥প  "":

⥫ 뢠 䠩
⥫  䠩
⥫ ᮧ ୨
୨ ⠥ 砫 ஢  䠩
    ,    
     த 
୨ 㤥   ஢ 䠩
⥫ ࠧ 䠩
⥫ 뢠 䠩  室
୨  䠩
                  ,
       ᠬ,
    騬  ⠭  ,
    騬 -᪨ ᯮ...
    ᮡ ⨣  
        -
    蠩   ,
       !
୨  뢠 䠩  室.

    ஢    䠩  稭    । ன ப
.  ୨        ⮩  窨,    
    ஢  ,    த⥫  ᫥  প   
᢮ .

     ୨  ⠥  ஢ 䠩,    ,
⮡  뫮  ⭮,    ந室..9-9  뢠  
plock.c  chlock.c  ६.


   䠩
   ஢ 䠩
    ᮧ 楯
   
Ŀ......
   পࠧ஢쳧প   室  
               䠩                䠩           
......
             㪮 ᨣ 
......Ŀ
           ⪠ - -    쳢室
                䠩        䠩  ⮡. 䠩 䠩       
......
                                          
      砫           ।
  䠩         ஢           ஢ 
                 


         .9-9. ६  plock.c  chlock.c


                  

      ⮩      ᭨  ࠧ  ᪮७ 믮
ணࠬ      ⠭  ᪮     -   뢮  c   㣮
⥫쭮.   㧭,      न஢   楯窨  ⥭  
      ᥬ    ᪫饣  㯠,  
 ᨭ஭ 㭪樨  - 뢮 DosReadAsync(),   
᪮쪨 ᥬ஢, ᯮ DosMuxSemWait().  ⠪ ᬮ५,
  ᯮ짮  ᥬ    ६  ⥭  ⮡ࠦ
᪮ 䠩  ࠭.

     ᫥    ᭨,  ந室,  ࠧ
      䠩. 㭪 DosOpen()  
 ࠬ  ᯥ稢 ᪫騩   ࠧ
᪮쪨   ᠬ   ६         䠩.   㭪
DosFileLock()      䠩.