      뢮 ⥪
    ===================

      뢮   ଥ, ਣ  ⥭, -
  ਬ ⥪⮢ 䠩   ᮮ⢥⢨    ⥬,
   ᠭ    ࠧ "⮢ 䠩" 饩 .
⮢ 䠩   祭   ன⢮, .. 
᪮  䠩     ⠭ ன /뢮-
.  樨   뢮  ⥪⮢ 䠩 믮 
ਬ 楤 READ,  READLN, WRITE  WRITELN, ᯨ᪨ -
ࠬ஢   ᮡ ,  ᯥ稢 ᨬ-
   /뢮.

     ⭮, ࠬ   ࠧ ⨯,  
砥 楤  /뢮  ।ᬠਢ  ⮬᪮
८ࠧ     ⨯ ⥪⮢ 䠩 CHAR  
.

    ᫨  ࠬ 楤 /뢮 -  -
 ६,  ।⠢饩 ⥪⮢ 䠩, 樨 -
/뢮 믮  ⨬ 䠩,   ⨢ 砥 -
樨 믮  ⠭묨 䠩 INPUT  OUTPUT,  
 ஡ ᠭ  ࠧ "⠭ 䠩"  饩
.

    楤 READ
    --------------

     楤    ᨬ, ப  -
 .

    ⠪:

    READ(Var1,Var2,..,VarN);

    READ(FilVar,Var1,Var2,..,VarN);

     Var1,Var2,..,VarN - ६ ⨯ CHAR, STRING, INTE-
GER  REAL.   ࢮ 砥 ६   ⠭-
 䠩 INPUT,  筮  .   ஬ 砥 -
    ⥪⮢  䠩,    ।⥫쭮
祭 ६ FilVar  ⮢  ⥭.

     ६ ⨯ CHAR  楤 뢠   ᨬ-
   䠩   ᢠ 祭 ⮣ ᨬ ६.
 ᪮ 䠩 㭪 EOLN 頥 祭 TRUE, ᫨
᫥騬 ᨬ  ᨬ CR  CTRL-Z.  㭪  EOF
頥  祭  TRUE,  ᫨ ᫥騩 ᨬ - CTRL-Z 
⨣ 䨧᪨  䠩.  ᫨ 䠩 ।⠢ ᮡ
᪮  ன⢮  ( ⠭ 䠩 INPUT  OUT-
PUT),   㭪 EOLN 頥 祭 TRUE,  ᫨ ⠭
ᨬ CR   ᫨ 㭪 EOF 頥 TRUE,   㭪 EOF
頥 TRUE, ᫨ ⠭ ᨬ CTRL-Z.

     ६ ⨯ STRING 楤  READ  ⠥  ⮫쪮
ᨬ, ᪮쪮  ᪠  ।  ᨬ쭠  
ப,    ,    㤥 ⨣    ப
   䠩.  㭪 EOLN 頥 祭 TRUE,  ᫨
⠭ ᨬ CR  ᫨  㭪  EOF  頥  TRUE,  
㭪  EOF  頥 TRUE,  ᫨ ⠭ ᨬ CTRL-Z 
祭 䨧᪨  䠩.

     ᫮ ६ (INTEGER  REAL)  楤  READ
 ப ᨬ,   ८ࠧ  ଠ ᫥-
 ⠭ ᮮ⢥饣 ⨯.  ஡, ᨬ ⠡-
樨, CR,  LF,  ।騥 ப, ய᪠. ப 
  ,  祬 30 ᨬ,     ᫥
    ᨬ CR, ⠡, CTRL-Z. ᫨ -
 ப    ८ࠧ  㦭 ଠ,  䨪-
 訡  /뢮.  ᫨ ८ࠧ 믮 -
譮, ᫥ 祭,  ஥ 뫠 ८ࠧ ப,
ᢠ 㪠  ६.    ⥭   ᪮
䠩, ᫨  ப 稢 ஡  ᨬ
⠡樨,  ᫥饬 맮 楤 READ  READLN ⥭
筥  ᨬ,  ।⢥ ᫥饣  ஡ 
ᨬ ⠡樨.   ᪮ 䠩, ⠪   -
 ன 㭪 EOLN 頥 祭 TRUE, ᫨ -
 稢 ᨬ CR  CTRL-Z, 㭪 EOF 頥
祭 TRUE, ᫨ ப 稢 ᨬ CTRL-Z.

            ,  
EOLN   EOF    祭 TRUE  ᠬ 砫 ⥭  -
 楤 READ (ਬ,     ⮫-
 ᨬ CR).   ⮬ 砥   祭 ६
 ᢠ,   ࠭ ᢮ ० 祭.

    ᫨ 䠩   祭 ᮫ (ன⢮ CON:),  
᫨ ᯮ  ⠭  䠩 INPUT  ० {$B+} (..
 㬮砭),  ⥭ ६ ந室  ᮡ ࠢ-
.  맮 楤 READ  READLN   ᮫ -
   ,  ⥬ ᯮ  -
  ⥭ 祭 ६.   ।஢
ଠ   . 㯭 ᫥騥 ।⢠ ।-
஢:

    BACKSPACE,    ந      ப
    DEL            㭨⮦ 室饣 ⠬ ᨬ. -
                  ⢨ BACKSPACE  筮   -
                  ⨨  <--   ⨨  CTRL-H.  DEL
                  筮   襩  ⠪  -
                  ஢  祭 .

    ESC,             砫  ப   ࠭  
    CTRL-X         ᨬ.     ESC  
                  祭  2.

    CTRL-D        ⠭         ᫥
                   ப.

    CTRL-R        ⠭ ᥩ ᫥  -
                  .

    RETURN          ᯮ   砭 
               ப.  ⮬ ਧ  ப (CR/LF)
    CTRL-M          .   CR/LF  ⮡-
                  ࠦ 宬   ࠭.    
                    祭    .

    CTRL-Z        襭  ப   ᥭ  થ
                   䠩 (CTRL-Z)   ப.

     ७ ।⠢ ப ࠭   
  ࠢ騬 ᨬ CTRL-Z.  ⮬, ᫨ ⢮
祭,   ப ,   ⢠ ६-
  ᯨ᪥ ࠬ஢  맮 楤 READ,    -
 ६  ⨯ CHAR  祭 CTRL-Z,  ६
⨯ STRING (⠪ 譨) ⠭ 묨,  ᫮ -
  묨.

    ᨬ쭮 ᫮ ᨬ, ஥  ᮤঠ -
   ᮫  ப,    㬮砭 ࠢ 127.   
㬥  । ⥬ ᢮ 楫 祭  0  
127 ।। ६ BUFLEN.

ਬ:
-------

    Write('File name (max 14 chars): ');
    BufLen:=14;
    Read(FileName);

    ⨬,  ᢮ ६ BUFLEN  祭  -
 ⮫쪮  ।⢥ ᫥騩  READ.  ᫥
⮣ 祭 BUFLEN ⠭ ࠢ 127.


    楤 READLN
    ----------------

     楤 筠 楤 READ,   ᪫祭 -
,  ᫥  ᫥ ६  ⠢訥 ᨬ
ப ய᪠,  ..   ᨬ  ᫥饩 ᫥-
⥫쭮 CR/LF ⥫쭮 (  ᫥饣 ᨬ  CR  
᪮ ன⢥).

    ⠪:

    READLN(Var1,Var2,..,VarN);

    READLN(FilVar,Var1,Var2,..,VarN);

    ᫥ 맮 楤 READLN ᫥騩 맮   -
楤 READ  READLN ਢ   ⥭    砫  ᫥饩
ப. 楤 READLN  뢠  ࠬ஢:

    READLN;

    READLN(FilVar);

     ⮬ 砥 ⮪ ப ய᪠.  뢠 
᮫  (⠭  䠩 INPUT  䠩,  ஬ 祭
ன⢮ CON:) 楤 READLN,  ⫨稥  楤 READ,
⮡ࠦ 騩  ᨬ  CR   ࠭   樨
CR/LF.


    楤 WRITE
    ---------------

     楤 ⢫ 뢮 ᨬ, ப, 㫥᪨
 ᫮ 祭.
    ⠪:

    WRITE(Var1,Var2,..,VarN);

    WRITE(FilVar,Var1,Var2,..,VarN);

     Var1,Var2,..,VarN -  ६ ⨯ CHAR, STRING,
BOOLEAN, INTEGER  REAL,      ᫥
稥  楫 ࠦ, ।饥 ਭ  뢮. 
ࢮ 砥  ६ 뢮  ⠭ 䠩 OUTPUT -
筮  ࠭.  ஬ 砥 ६ 뢮  ⥪-
⮢ 䠩, ࠭ 易  䠩 ६ FilVar.
    ࠬ Var1,Var2,..,VarN  뢠  ࠬࠬ  뢮,
ଠ    ⨯ ६.  ਢ -
ᠭ ࠧ ଠ⮢  ⮣,     ࠡ.    ⮬
ਬ ᫥騥 祭:

    I,M,N  -  ࠦ ⨯ INTEGER;
    R      - 砥 ࠦ ⨯ REAL;
    Ch     - 砥 ࠦ ⨯ CHAR;
    S      - 砥 ࠦ ⨯ STRING;
    B      - 砥 ࠦ ⨯ BOOLEAN.


    ࠬ 뢮:

    Ch     - 뢮 ᨬ Ch.
    Ch:N   -  Ch 뢮  ࠢ ஭   ਭ
             N ᨬ,  .. ᨬ Ch । N-1 -
             .
    S      - 뢮 ப S.  ᨢ ᨬ ⠪  
             뢮, ⠪   ᮢ⨬  ப.
    S:N    - ப S 뢮   ࠢ  ࠢ -
               ਭ N ᨬ,  .. ப S ।-
              N-Length(S) ஡.
    B      -  ᨬ    祭  뢮   ᫮
             TRUE,  ᫮ FALSE.
    B:N    -  ᨬ    祭  뢮   ᫮
             TRUE,  ᫮ FALSE, ஢  ࠢ -
               ਭ N ᨬ.
    I      - 뢮 筮 ।⠢ 祭 I.
    I:N    - 뢮 筮 ।⠢ 祭 I, -
             ஢  ࠢ ࠭   ਭ N ᨬ-
             .
    R      - 뢮 筮 ।⠢ 祭 R, -
             ஢ ࠢ   ਭ 18 ᨬ  -
               饩 ⮩:
                  R>=0.0:  __#.##########E*##
                  R< 0.0:  _-#.##########E*##
               _  ।⠢  ஡,  #  ।⠢
             , * ।⠢  + ,  - .
    R:N    - 뢮 筮 ।⠢ 祭 R, -
             ஢   ࠢ ࠭  ਭ N ᨬ-
             ,  ଠ  饩 ⮩:
                  R>=0.0:  ஡ #.E*##
                  R< 0.0:  ஡-#.E*##
              "஡" -  0   ஡,  ""
             -   1  10 ,  #  ।⠢  ,  *
             ।⠢   +  ,   - .  ᪮ ᫥
             筮 窨 뢮   ࠩ    
             , 쭠  ਭ    ࠢ 7 ᨬ
             (8, ᫨ R<0). ᫨ N>16 (N>17  R<0),  -
              ।⢮ N-16 (N-17, ᫨ R<0) ஡.
    R:N:M  - 뢮 筮 ।⠢ 祭 R, -
             ஢   ࠢ ࠭  ਭ N ᨬ-
               ଠ  䨪஢ ⮩  M  ࠬ
             ᫥ 筮 窨.  ᫨ M=0,   뢮
              ஡ ,   筠  窠.  ᫮  M
                    0  24,   ⨢
             砥 㤥 ᯮ짮 ଠ  饩  -
             ⮩.    ।  室  ⢮
             ஡ ⠪ ࠧ,   ਭ   ࠢ  N
             ᨬ.


    楤 WRITELN
    -----------------

     楤 筠 楤 WRITE,  ᪫祭 -
,   ᫥   ᫥ 祭 뢮 ᫥⥫-
 CR/LF.

    ⠪:

    WRITELN(Var1,Var2,..,VarN);

    WRITELN(FilVar,Var1,Var2,..,VarN);

    맮 楤  WRITELN    ࠬ஢ 뢮 ਢ 
뢮 ⮩ ப, 饩  ᫥⥫쭮 CR/LF:

    WRITELN;

    WRITELN(FilVar);



    ,  騥 ⨯
    ======================

    ,  騥 ⨯, (䠩  ⨯)  ।⢮
/뢮  ஢;   ᯮ   ।
 אַ 㯠   ᪮ 䠩    ᯮ짮
  128 .

      /뢮  䠩,   騬 ⨯, -
   묨  ।⢥    ६  
᪮ 䠩; ⠪ ࠧ   , 뤥-
塞   ⢥    ᥪ  䠩   ⨯.
६,  䠩,  騬 ⨯,  
, 祬  㣠 ६ ⨯ FILE.  ᪮ 䠩,
 騩 ⨯,   ᮢ⨬    䠩, ᯮ짮
⠪ 䠩  ।⥫쭮  ⮫쪮 ⮣,   易 
 ६ ᯮ ⮫쪮   饭    楤ࠬ
ERASE, RENAME   㣨 ,  易  /-
.

    ,  騩 ⨯,  १ࢨ஢ ᫮
FILE:

    var
      DataFile: File;


    楤 BLOCKREAD  BLOCKWRITE
    --------------------------------

     楤  㭪樨,  ਬ  ⠭  䠩,
஬ READ,  WRITE,  FLUSH,  ࠧ蠥 ਬ  䠩, 
騬 ⨯.   楤 READ  WRITE  ᯥ樠
᮪᪮ 楤 : BLOCKREAD  BLOCKWRITE.

    ⠪:

    BLOCKREAD (FilVar,Var,Recs);
    BLOCKWRITE(FilVar,Var,Recs);

    BLOCKREAD (FilVar,Var,Recs,Result);
    BLOCKWRITE(FilVar,Var,Recs,Result);

     FilVar - 䨪 ६,  易   䠩
 ⨯, Var -  ६, Recs -  楫 ࠦ, -
।饥 ᫮ 128- ᥩ,  । 
᪮ 䠩    ६,  易⥫ ࠬ Result
ᮤন ⢮ ॠ쭮 । ᥩ.  । -
  ࢮ ,  ६ Var. ணࠬ
 ᯥ,  ⮡ ६  Var    筮
  । . 맮 BLOCKREAD  BLOCKWRITE த-
 㪠⥫ 䠩  Recs ᥩ ।.

    , 騩  ࠡ⪥    楤 BLOCKREAD 
BLOCKWRITE,   ᭠砫 ⮢      맮
楤 ASSIGN    楤 REWRITE  RESET.  -
 REWRITE ᮧ  뢠  䠩,   楤 RESET
뢠 騩 䠩.   砭 ࠡ⪨ 䠩 -
室    楤 CLOSE.

    ⠭⭠ 㭪 EOF ࠡ⠥ 筮 ⠪ ,    䠩-
, 騬  ⨯.  筮  ࠡ  ⠭ 㭪樨
FILEPOS  FILESIZE,    ⠪  ⠭⭠  楤  SEEK,  
ᯮ짮   128 .

     ணࠬ  ਬ 䠩,  -
饣 ⨯.    ⠥  ᪮ 䠩    -
ন   㣮 ᪮ 䠩.    -
짮 易⥫쭮   ⢥⮣   ࠬ  楤
BLOCKREAD  ஫ ⢠ ᥩ, ॠ쭮 ⠭ 
室 䠩.

    program FileCopy;

    const
      RecSize = 128;
      BufSize = 200;
    var
      Sour,
      Dest:     File;
      SourName,
      DestName: string[14];
      Buffer:   array[1..RecSize,1..BufSize] of Byte;
      RecsRead: Integer;

    begin
      Write (' 䠩 筨: ');
      ReadLn (SourName);
      Assign (Sour,SourName);
      Reset (Sour);
      Write (' 䠩 ਥ: ');
      ReadLn (DestName);
      Assign (Dest,DestName);
      Rewrite (Dest);

      repeat
        BlockRead (Sour,Buffer,BufSize,RecsRead);
        BlockWrite(Dest,Buffer,RecsRead);
      until RecsRead = 0;

      Close (Sour);
      Close (Dest);
    end.



    ஫ /뢮
    =====================

    ४⨢  I ᯮ  ࠢ -
樥 ,  㦨饣     믮 訡 -
/뢮.  㬮砭  ० 祭,  ..  {$I+} ,  
ਢ   맮 ணࠬ ஫ /뢮 ᫥ -
 樨 /뢮. 訡 /뢮 뢠 ४-
饭 믮 ணࠬ  뤠 ᮮ饭, 㪠뢠饣 ⨯
訡.

    ᫨  ० 몫祭,  ..  {$I-} ,   ६ ࠡ
ணࠬ ஢ઠ  믮. 訡 /뢮  -
  ⮬ ⠭ ணࠬ,    쭥訥 -
樨 /뢮   ਮ⠭   ,  
㤥  맢  ⠭⭠  㭪 IORESULT.   맮 ⮩
㭪樨 ﭨ 訡 뢠,   樨 /뢮
 믮 ᭮. ணࠬ  ᠬ 믮 ᮮ-
騥 ⢨  ᨬ  ⨯ 訡 /뢮.
, 頥 㭪樥 IORESULT, ᢨ⥫  ᯥ-
 믮 ᫥ 楤 /뢮;    㣮
祭 砥,  ᫥  /뢮 -
  訡.  ਫ G ᮤন     訡  -
/뢮   ᮮ⢥騥   ᮮ饭.  ⨬,   ᫨
ﭨ 訡 襭 맮 㭪樨 IORESULT, ᫥騥
맮 㭪樨 IORESULT      ,  
 ந ᫥ 訡 /뢮.

    㭪 IORESULT 祭 㤮   ,   -
 ணࠬ  ਥ  ॠ樥    訡  -
/뢮,     ᫥饬 ਬ,   த 
 䠩   ,   ⪠      
ᯥ譮 (..   㤥   㦥 饣 䠩-
).

    procudure OpenInFile;
    var
      InFileName: string[14];
      InFile: File;
      Ok: Boolean;
    begin
      repeat
        Write ('  䠩: ');
        ReadLn (InFileName);
        Assign (InFile,InFileName);
        {$I-}
        Reset (InFile);
        {$I+}
        Ok:=(IOresult=0);
        if not Ok then
           WriteLn (' ',InFileName,'   !');
      until Ok;
    end.


     ४⨢ I ⪫祭, .. {$I-}, १ 믮-
 ᫥  ⠭  楤  㦭 ஢  
맮 㭪樨 IORESULT, ⮡   訡:

    Assign       Close     Read      Rewrite
    BlockRead    Erase     ReadLn    Seek
    BlockWrite   Execute   Rename    Write
    Chain        Flush     Reset     Writeln
