     楤 ࠢ ࠡ⮩ ணࠬ -  楤,  -
ࠢ騥  믮 ணࠬ.
Ŀ
  楤             ᠭ                              
Ĵ
   Break            蠥  for, while  repeat. 
Ĵ
   Continue         த   for,  while,
                     repeat.                               
Ĵ
   Eit                 ⥪饣 -
                    .                                     
Ĵ
   lt             ⠭ 믮 ணࠬ  -
                    頥 ࠢ 樮 ⥬.   
Ĵ
   RunError         ⠭ 믮 ணࠬ  -
                     訡 ⠯ 믮.           


                    㭪樨 ८ࠧ


      ᫥ 㭪樨 ८ࠧ.

Ŀ
    㭪              ᠭ                             
Ĵ
   Chr             頥 ᨬ,  楫 ᫮.  
Ĵ
   High            頥 襥 祭   -
                   㬥.                                   
Ĵ
   Low             頥 襥 祭   -
                   㬥.                                   
Ĵ
   rd             頥 浪 ᫮  祭 -
                   ᫨ ⨯.                          
Ĵ
   Rund           㣫 祭  ⢥  ⨯  
                   祭, 饣  楫 ⨯.      
Ĵ
   run           ᥪ 祭 ⢥ ⨯  -
                   祭, 饣  楫 ⨯.         


                    䬥᪨ 㭪樨


      㭪樨  ᯮ짮  믮 䬥-
 権.

            ਬ砭: 祭, 頥 楤ࠬ -
       権   饩  ⮩  System,   樨 
       ० ᫮ ࠡ⪨ (४⨢ {$N+}),    -
       ⢥ ⨯ (real),  ७ (extended).

Ŀ
    㭪              ᠭ                             
Ĵ
   Abs             頥 ᮫⭮ 祭 㬥.  
Ĵ
   rctan          頥 ⠭ 㬥.           
Ĵ
   Cs             頥 ᨭ 㬥.              
Ĵ
   Ep             頥 ᯮ 㬥.           
Ĵ
   Fr            頥 ஡  㬥.        
Ĵ
   Int             頥 楫  㬥.          
Ĵ
   Ln              頥 ࠫ  㬥. 
Ĵ
   Pi              頥 祭 ᫠ Pi               
                   (3.141592653897932385).                    
Ĵ
   Sin             頥 ᨭ 㬥.                
Ĵ
   Sqr             頥 㬥  .            
Ĵ
   Sqrt            頥  ७ 㬥.    


                浪 楤  㭪樨


Ŀ
 楤/㭪            ᠭ                        
Ĵ
     D           蠥 祭 ६.             
Ĵ
     In           稢 祭 ६.           
Ĵ
     dd           ஢,     㬥  묳
                   ᫮.                                    
Ĵ
     red          頥 ।饥 祭 㬥-
                   .                                        
Ĵ
     Su          頥  ᫥饥 祭.       


                 ப 楤  㭪樨


     騥 楤    㭪樨  ᯮ   ࠡ 
ப ᪠.

Ŀ
   楤            ᠭ                              
Ĵ
    Cncat         믮 ⥭   ᫥⥫쭮⨳
                   ப.                                     
Ĵ
    C           頥 ப ப.               
Ĵ
    Delete           ப ப.               
Ĵ
    Insert           ப ப.              
Ĵ
    Length         頥   ப.      
Ĵ
    Ps            ந  ப  ப.       
Ĵ
    Str            ८ࠧ ᫥  祭   -
                    ।⠢.                       
Ĵ
    Val            ८ࠧ ப 祭     -
                    ।⠢.                      


    楤  㭪樨 ᪮ । 


      楤   㭪樨 ᯮ  ࠢ -
᪨ ।塞  -  ,  
  ᢮       ,    믮
ணࠬ.   ᠭ ⮤,  ᯮ㥬  ࠢ
᪨  ।塞    ਢ  ࠧ
"ணࠬ ᪮ । "   21  ("-
 ࠢ ").

          楤 ᪮ । 
Ŀ
 楤/㭪            ᠭ                        
Ĵ
   Dispose         ⮦  ६.        
Ĵ
   Fr         ⮦   ६ 
                   ࠧ.                                   
Ĵ
   Get              ६  -
                     ࠧ  ⠭   -
                   ६-㪠⥫.                        
Ĵ
   vail        頥 ࠧ  襣 뢭
                   ᢮   ᪨ ।-
                     , ᮮ⢥騩 ࠧ-
                    襩 ᪮ ६,  -
                      뤥   饭  
                   Avail.                                  
Ĵ
   vail        頥 ⢮     -
                   ᪨  ।塞      ᢮
                   .                                      
Ĵ
   New                ६  -
                   ⠭   ६-㪠⥫.   


          㭪樨  ࠡ  㪠⥫ﬨ  ᠬ


      ᫥  㭪樨  ࠡ  㪠⥫ﬨ  -
.

Ŀ
    㭪樨                     ᠭ                      
Ĵ
    ddr           頥   ꥪ.        
Ĵ
    CSeg           頥 ⥪饥 祭 ॣ CS.   
Ĵ
    DSeg           頥 ⥪饥 祭 ॣ DS.   
Ĵ
    fs            頥 ᬥ饭   ꥪ. 
Ĵ
    Ptr            ८ࠧ   ᥣ   ᬥ-
                   饭  祭 ⨯ 㪠⥫.           
Ĵ
    Seg            頥 ᥣ   ꥪ.  
Ĵ
    SPtr           頥 ⥪饥 祭 ॣ S.   
Ĵ
    SSeg           頥 ⥪饥 祭 ॣ SS.   


                  稥 楤  㭪樨


Ŀ
 楤/㭪            ᠭ                        
Ĵ
   Exclude         ᪫砥   ⢠.            
Ĵ
   FillChar          ᫮ ᫥   
                   㣮  㪠 祭.            
Ĵ
   Hi              頥 訩  㬥.         
Ĵ
   Include         砥   ⢮.              
Ĵ
   Lo              頥 訩  㬥.         
Ĵ
   v               ᫮ 뢭  
                   㪠 ࠭       -
                   , ࠭ ண ⠪ 㪠뢠.   
Ĵ
   ParamCount      頥   ᫮  ࠬ஢,  ।
                   ணࠬ   ப.              
Ĵ
   ParamStr        頥 ࠬ,     
                   ப.                                    
Ĵ
   Random          頥 砩 ᫮.                
Ĵ
   Rndiz       樠 ஥  砩-
                    ᥫ 砩 祭.             
Ĵ
   SizeOf          頥 ᫮ ,   㬥-
                   ⮬.                                       
Ĵ
   Swap             ⠬  訩  訩  -
                   㬥.                                   
Ĵ
   TypeOf          뢠   ⠡  㠫  ⮤
                   ꥪ.                                   
Ĵ
   UpCase          ८ࠧ ᨬ  孨 ॣ.      


                   ।ᠭ ६


     ஬ 楤  㭪権  㫥  System  ।ᬮ७  
।ᠭ ६.    祭   ⥪ -
饩 ⥬,  ன ⭮  System.

     騥 ६ 뢠  㫥 System  ⥪
TURBO.TPL -  ⥪ ᯮ饩 ⥬  ਫ ॠ-
 ० DOS.

Ŀ
 ६                      ᠭ                 
Ĵ
 ErrorAddr      Pointer          訡 ⠯  믮- 
                                                          
Ĵ
 ExitProc       Pointer         楤 室             
Ĵ
 ExitCode       Integer          室                   
Ĵ
 FileMode       Byte            ०  䠩         
Ĵ
 FreeList       Pointer         ᯨ᮪ ᢮   - 
                                ᪨ ।塞 - 
                                                  
Ĵ
 FreeZero       Pointer           ࠢ 0          
Ĵ
 HeapOrg        Pointer         砫 ᪨ ।- 
                                塞                
Ĵ
 HeapPtr        Pointer         㪠⥫  ᪨  - 
                                ।塞           
Ĵ
 HeapError      Pointer         㭪  訡  ᪨ 
                                ।塞  - 
                                                           
Ĵ
 Input          Text            ⠭ 䠩        
Ĵ
 InOutRes       Integer            १  樨 
                                -뢮                 
Ĵ
 Output         Text            ⠭ 䠩 뢮      
Ĵ
 OvrCodeList    Word            ᯨ᮪ ᥣ⮢ ૥ 
                                                         
Ĵ
 OvrDebugPtr    Pointer         ᯮ      ⫠ 
                                ૥                     
Ĵ
 OvrDosHandle   Word            ⥫ ૥ DOS        
Ĵ
 OvrEmsHandle   Word            ⥫ ૥ EMS        
Ĵ
 OvrHeapEnd     Word             ૥      
Ĵ
 OvrHeapOrg     Word            砫 ૥     
Ĵ
 OvrHeapPtr     Word            㪠⥫ ૥  
Ĵ
 OvrHeapSize    Word            砫 ࠧ ૥ 
                                                       
Ĵ
 OvrLoadList    Word            ᯨ᮪ 㦥 ૥  
Ĵ
 PrefixSeg      Word            䨪 ணࠬ ᥣ- 
                                                           
Ĵ
 RandSeed       Longint         砩  ᫮  (- 
                                 稪  砩 - 
                                ᥫ)                         
Ĵ
 SaveInt00      Pointer         ࠭ 뢠 $00   
Ĵ
 SaveInt02      Pointer         ࠭ 뢠 $02   
Ĵ
 SaveInt1B      Pointer         ࠭ 뢠 $1B   
Ĵ
 SaveInt23      Pointer         ࠭ 뢠 $23   
Ĵ
 SaveInt24      Pointer         ࠭ 뢠 $24   
Ĵ
 SaveInt34      Pointer         ࠭ 뢠 $34   
Ĵ
 SaveInt35      Pointer         ࠭ 뢠 $35   
Ĵ
 SaveInt36      Pointer         ࠭ 뢠 $36   
Ĵ
 SaveInt37      Pointer         ࠭ 뢠 $37   
Ĵ
 SaveInt38      Pointer         ࠭ 뢠 $38   
Ĵ
 SaveInt39      Pointer         ࠭ 뢠 $39   
Ĵ
 SaveInt3A      Pointer         ࠭ 뢠 $3A   
Ĵ
 SaveInt3B      Pointer         ࠭ 뢠 $3B   
Ĵ
 SaveInt3C      Pointer         ࠭ 뢠 $3C   
Ĵ
 SaveInt3D      Pointer         ࠭ 뢠 $3D   
Ĵ
 SaveInt3E      Pointer         ࠭ 뢠 $3E   
Ĵ
 SaveInt3F      Pointer         ࠭ 뢠 $3F   
Ĵ
 SaveInt75      Pointer         ࠭ 뢠 $75   
Ĵ
 Seg0040        Word            ᥫ ᥣ $0040      
Ĵ
 SegA000        Word            ᥫ ᥣ $A000      
Ĵ
 SegB000        Word            ᥫ ᥣ $B000      
Ĵ
 SegC000        Word            ᥫ ᥣ $C000      
Ĵ
 SelectorInc    Word            蠣 㢥祭 ᥫ     
Ĵ
 StackLimit     Word            㪠⥫   ࠭  
                                ⥪                        
Ĵ
 Test8086       Byte            १  ஢ન  - 
                                 8086                    
Ĵ
 Test8087       Byte            १ ஢ન ᮯ- 
                                 8087                    


     PrefixSeg ।⠢ ᮡ ६   ᫮,  -
ঠ  䨪 ணࠬ ᥣ (PSP), ᮧ
 믮 ணࠬ 樮 ⥬ DOS.  -
 PSP ਢ  㪮⢥  樮 ⥬ DOS.

     ६ StackLimit ᮤন ᬥ饭 砫 ⥪ ⭮-
⥫쭮 ᥣ ⥪,  ᮮ⢥ 쭮 ⨬
祭 ॣ SP, ᫥ ண 㦥   -
 ⥪.  㬮砭 祭 ⮩ ६ ࠢ 0, 
᫨ ணࠬ   ४⨢ {$N+,$E+},  
ᮯ 8087  ⢨  ⥬ ᮯ  8087 
१ࢨ஢     ᥣ ⥪ 㤥 -
   祭 224.


     ६ InOutRes  ᯮ  ஥묨   ணࠬ
-뢮  ࠭ 祭, 頥  ᫥饬
饭  㭪樨 IOResult.

      RandSeed ࠭ 砫쭮  祭    ஥
 砩 ᥫ.  ᫨ ᢠ ⮩ ६ -
। 祭,   㭪 Random 㤥 ஢ -
  ᫥⥫쭮 砩 ᥫ.

     ६ FileMode    ० 㯠  -
 ⨯஢  ⨯஢  䠩.

      ६  Test8087 ࠭ १ ࠡ -
 ⮬᪮ ᯮ ᮯ 8087,   -
稭 ࠡ  ᪥ ணࠬ,  ᪮஢  ४-
⨢  {$N+}.

     Input  utput -  ⠭ 䠩 -뢮, -
   ॠ樨 ᪠.   㬮砭   뢠
 ⠭묨 室묨  室묨 䠩  Dos.



     ⥬ ࠢ  ᪨  ।塞 
  ॠ樨 ணࠬ ᪮ । 
Borland Pascal   ᯮ   ६  HeapList,  HeapLimit,
HeapBlock  HeapError.

      ॠ樨  楤  室   ᯮ   ६
ExitProc, ErrorCode  ErrorAdr.

     ६ PrefixSeg  ।⠢ ᮡ ६  
᫮,  ᮤঠ  䨪  ணࠬ  ᥣ  (PSP),
ᮧ   믮 ணࠬ 樮 ⥬ DOS.
 ᠭ PSP ਢ  㪮⢥  樮  -
⥬ DOS.

     ६ InOutRes   ᯮ  ஥묨  ணࠬ
-뢮  ࠭ 祭, 頥  ᫥饬
饭  㭪樨 IOResult.

     ६ FileMode   ० 㯠   -
 ⨯  ⨯஢ 䠩.   ஡ 
ᠭ   14 "  뢮".

     騥 ६ 뢠  㫥 System  ⥪
TPP.TPL - ⥪ ᯮ饩 ⥬  ਫ  饭-
 ० DOS.

Ŀ
 ६                      ᠭ                 
Ĵ
 ErrorAddr      Pointer          訡 ⠯  믮- 
                                                          
Ĵ
 ExitProc       Pointer         楤 室             




                     14.   뢮


        ⪮ 뢠 ⠭ (  ஥-
) 㭪樨  楤 -뢮 Borland Pascal.   -
  㭪樨    㫥 System.

                楤  㭪樨 -뢮
Ŀ
   㭪              ᠭ                              
Ĵ
   Append          뢠 騩  䠩    -
                   .                                       
Ĵ
   Assign          ᢠ  譥 䠩 䠩 -
                   ६.                                  
Ĵ
   BlockRead       뢠   ⨯஢ 䠩  
                     ᥩ.                         
Ĵ
   BlockWrite      뢠    ⨯஢  䠩  
                     ᥩ.                         
Ĵ
   ChDir           믮 ᬥ ⥪饣 ⠫.         
Ĵ
   Close           뢠  䠩.                   
Ĵ
   Erase           ࠥ 譨 䠩.                      
Ĵ
   Ef             頥  䠩  ﭨ end-of-file
                   ( 䠩).                             
Ĵ
   FilePos         頥 ⥪      䠩.  
                   ⥪⮢ 䠩  ᯮ.          
Ĵ
   FileSize        頥 ⥪騩 ࠧ 䠩.   ⥪-
                   ⮢ 䠩  ᯮ.              
Ĵ
   Flush           뢠  ⥪⮢ 䠩 뢮.  
Ĵ
   Getdir          頥 ⥪騩 ⠫   -
                   .                                        
Ĵ
   IResult        頥 楫 祭,  饥 -
                   ﭨ ᫥ 믮 樨 -
                   -뢮.                                 
Ĵ
   MkDir            ⠫.                        
Ĵ
   Read            뢠    祭   䠩
                       ६.               
Ĵ
   Readln            ,   Read,  믮  -
                     砫 ᫥饩 ப  ⥪⮢
                   䠩.                                     
Ĵ
   Rn          २뢠 譨 䠩.              
Ĵ
   Rset           뢠 騩 䠩.               
Ĵ
   Rewrit           뢠  䠩.            
Ĵ
   RDir            ⮩ ⠫.                 
Ĵ
   Seek            ६頥 ⥪   䠩    -
                    .  ⥪⮢ 䠩  -
                   .                                
Ĵ
   SeekEof         頥  ⥪⮢  䠩  ﭨ
                   " 䠩".                             
Ĵ
   SeekEoln        頥  ⥪⮢  䠩  ﭨ
                   " ப".                            
Ĵ
   SetTextBuf      砥  ⥪⮢ 䠩  -
                   뢮.                                    
Ĵ
   Truncate        ᥪ ࠧ 䠩    ⥪饩  樨.
                    ⥪⮢ 䠩  ᯮ.      
Ĵ
   Write           뢠  䠩    祭. 
Ĵ
   Writeln           ,   Write,  ⥬  -
                     ⥪⮢ 䠩 ᨬ  ப. 


                       -뢮


      ६   ᪠ -   ६ 䠩-
 ⨯.   ᪠     䠩:  ⨯஢
䠩, ⥪⮢ 䠩  ⨯஢ 䠩.

           ਬ砭: ⠪   ⨯ 䠩 ।⠢
        4,  ࠧ " ⨯".

     । ᯮ짮 䠩  ६      
易  譨 䠩   맮 楤 Assign. -
 䠩 筮   䠩    ᪥,    
⠪  ।⠢ ᮡ ன⢮,  ਬ,  
 ᯫ.   譨 䠩 ࠭ ᠭ  䠩 -
ଠ,   㦠 筨 ଠ樨,  뢠-
  䠩.

        譨 䠩 ⠭,   ⮢ 
 樨   뢮 䠩 ६   "-
". 騩 䠩     楤 Reset,
  䠩  ᮧ     楤 Rewrite.
⮢ 䠩,       楤  Reset  㯭
⮫쪮  ⥭,  ⥪⮢ 䠩,    楤
Rewrite,  㯭 ⮫쪮  . ஢  ⨯-
 䠩 ᥣ ᪠  ⥭, ⠪  , -
  ⮣ 뫨     楤 Reset     -
 楤 Rewrite.

      䠩,  ।⠢  ᮡ  ᫥⥫쭮
⮢,      ⨯  ( ⨯ )
䠩.      䠩  .    䠩
⠥ 㫥 ⮬.

     筮     䠩  ࣠  ᫥⥫쭮,  
,     뢠   ⠭⭮ 楤
Read  뢠   ⠭⭮ 楤 Write,  -
  䠩 ६頥  ᫥饬  浪 
䠩.    ⨯஢  ⨯஢  䠩  
࣠  אַ    ⠭⭮ 楤 Sk,
 ६頥 ⥪  䠩      .
  । ⥪饩 樨  䠩  ⥪饣 ࠧ 䠩
 ᯮ짮 ⠭ 㭪樨 FilePs  Filesize.

      ணࠬ 蠥 ࠡ 䠩,    -
   ⠭⭮ 楤 Close.  ᫥  -
 䠩 易   譨 䠩 .  ⥬ 䠩-
 ६   易  㣨 譨 䠩.

      㬮砭   饭   ⠭  㭪  
楤ࠬ  -뢮  ⮬᪨  ந ஢ઠ 
稥 訡.  㦥 訡 ணࠬ ४頥 ࠡ-
    뢮   ࠭ ᮮ饭  訡.    ४⨢
 {$I+}  {$I-}  ⮬ ஢  -
  몫.   ⮬᪠ ஢ઠ ⪫祭,  
  楤  㭪 뫠 ᪮஢  ४⨢
{$I-},  訡 -뢮, 騥  ࠡ ணࠬ, 
ਢ   ⠭.   ⮬,  ⮡ ஢ १ -
  樨  -뢮,  㦭 ᯮ짮 ⠭
㭪 IResult.

      ⪨ 訡,    ந,   -
 㭪 IOResult.  ᫨  ⮣  ᤥ,  ⥪騬 -
ﭨ  {$I+},   - ⠢襩 訡 IOResult ᫥-
  -뢮   訡.

           ਬ砭: ᫨   ணࠬ  Windows    
      ,  ⮡ Windows ࠡ뢠   訡 --
             㣨  訡  -뢮,  맮
      SetErrorMode(1).

                        ⮢ 䠩


       ࠧ 뢠 樨     뢮,  -
騥 䠩 ६ ⠭⭮ ⥪⮢ ⨯.  -
⨬,    Borland Pascal ⥪⮢ ⨯ (⨯ Text)  ⫨砥
 ᨬ쭮 ⨯ Char.

      ⨨  ⥪⮢ 䠩 譨 䠩 
ᮡ ࠧ:  ⠥,    ।⠢ ᮡ ᫥-
⥫쭮 ᨬ,  㯯஢  ப,    ப
稢 ᨬ  ப (end-of-line),  ।-
⠢ ᮡ ᨬ ॢ ⪨,    ᫥-
 ᨬ ॢ ப.

      ⥪⮢ 䠩    ᯥ樠    権
⥭   (read  write),    뢠 
뢠 祭,  ⨯  ⫨砥  ᨬ쭮  ⨯
Char.    祭  ⮬᪨  ॢ    ᨬ쭮
।⠢  ⭮.  ਬ, Read(f,i),  i - ६
楫 ⨯,  ਢ  뢠 ᫥⥫쭮 ,  -
樨 ⮩ ᫥⥫쭮,    筮  ᫠,  
࠭   i.

      뫮 ⬥祭 ࠭,    ⠭ ६
⥪⮢ ⨯ -  Input  utput.  ⠭⭠ 䠩 -
 Input -  㯭 ⮫쪮  ⥭ 䠩,  易 
⠭ 䠩  樮 ⥬ (筮  -
),    ⠭⭠ 䠩 ६ utput -  㯭
⮫쪮   䠩,  易   ⠭  䠩  뢮
樮 ⥬ (筮  ᯫ). । 砫 믮-
 ணࠬ DOS 䠩 Input  utput ⮬᪨ 뢠,
 ᫨  뫨 믮 ᫥騥 :

     Assign(Input,'');
     Reset(Input);
     Assign(Output,'');
     Rewrite(Output);

       Windows  ন  ।⢥  ਥ-
  ⥪   뢮, 䠩 Input  Output  㬮砭 
ਪ ணࠬ Windows  ᢠ,      ⪠
⥭      䠩      ਢ  訡 -
-뢮.  ,  ᫨ ਪ ணࠬ ᯮ  
WinCrt,  Input  Output  뫠  ப稢 ⥪-
⮢ .  WinCrt ᮤন   ࠢ, -
     樨  ⥪⮢  ࠭    樮  ।
Windows,  ⮬   ਪ  ணࠬ,  ᯮ饩  
WinCrt,   ॡ  ਥ ணࠬ஢,  ᯥ-
᪨  Windows.

        ⠭ 楤  㭪権,  ᯨ᮪ -
  ਢ    ࠧ,   ॡ  㪠뢠 
⢥ ࠬ  䠩 ६.  ᫨  ࠬ -
饭,    㬮砭  ᬠਢ ६ Input  
Output,    ᨬ   ⮣,  㤥  楤  㭪
ਥ஢     뢮.  ਬ,  Read() ᮮ⢥-
 Read(Input,)  Write() ᮮ⢥ Write(Output,).

     ᫨  맮   楤  㭪権  ⮣  ࠧ-
   䠩,  䠩   易  譨 䠩-
   楤  Assign          楤
Reset, Rewrit  Append. ᫨  ਥ஢  뢮 -
楤  㭪樨  㪠뢠 䠩,       -
 楤 Reset,   뢥 ᮮ饭  訡.  -
筮,  㤥 訡   ਥ஢   -
    㭪樨 䠩,     楤 Rewrite 
Append.

                    ⨯஢ 䠩


     ⨯஢ 䠩 ।⠢ ᮡ  -뢮-
  ஢,  ᯮ㥬  ᭮  אַ 㯠 
 䠩  ᪥,  ᨬ   ⨯  . 
⨯஢ 䠩 뢠 ᫮ file  ਡ⮢. -
ਬ:

     var
       DataFile: file;

      ⨯஢ 䠩  楤 Reset  Rewrite -
᪠ 㪠뢠 ⥫ ࠬ,  ⮡  ࠧ
, ᯮ騩  । 䠩.

      ᪨ 稭 ਭ  㬮砭   -
  ࠢ  128 ⠬.  ।⥫쭮   
 ,  ࠢ 1, ᪮  ⢥ 祭, -
஥    筮 ࠧ ࠧ  䠩 ( 
 ࠢ 1,   䠩   ⢮  -
,     襩 ).

      ᪫祭 楤 Read  Write   ⨯஢-
 䠩 ᪠ ᯮ짮  ⠭⭮ 楤,
 ᪠ ᯮ짮  ⨯஢묨 䠩. -
 楤 Read  Write  ᯮ ᮮ⢥⢥ -
 Blockrd  BlockWrite 騥 뫠   -
 ᪮.

                      ६ FileMode


     ६ FileMode,  ।   㫥 System,  
 㯠,  ।  DOS  ⨯஢  ⨯-
 䠩 (  ⥪⮢ 䠩),    뢠 
 楤 Reset.

      㬮砭  祭  FileMode  = 2.   ⮬ ᪠
⥭   䠩.  ᢠ  FileMode  㣮  祭
ਢ   ᯮ짮 ⮣ ०   ᫥ 맮-
 Reset.

           ਬ砭:    䠩,   뢠      
      Rewrite, ᥣ 뢠  ० ⥭/,  -
      ⢥ Filemode = 2.

      ⨬ 祭 FileMode    ᯮ-
 ᨨ DOS.     । ᫥騥 ०-
:

     0:   ⮫쪮  ⥭
     1:  쪮 
     2:  ⥭/

      DOS  ᨨ 3. । ⥫ ०,  
  ᭮ ᮢ⭮ ᯮ짮 䠩  ࠡ 
  ( ஡  뢠  "㪮⢥ ணࠬ
 DOS").

                  ன⢠  Borland Pascal


      Borland  Pascal   樮 ⥬ DOS  -
,  ,  ਬ,  , ன⢮ , ᯫ,
ᬠਢ,  ன⢠.  窨 ७ ணࠬ -
ன⢮  ᬠਢ,   䠩,      ࠡ 
  ⮣    ⠭ 楤  㭪権,    
䠩.   ࡮ ᪠ ন  ⨯ ன - -
ன⢠ DOS  ன⢠  ⥪⮢ 䠩.

                        ன⢠ DOS


     ன⢠ DOS  ॠ   १ࢨ஢ 
ன,    ᯥ樠 .  ன⢠ DOS -
 "஧":  ࡮ ᪠ ⭮ ,  䠩-
 ६ 易  ன⢮,     䠩  ᪥.
ਬ, ணࠬ:

     var
       Lst: Text;
     begin
       Assign(Lst,'LPT1');
       Rewrite(Lst);
       Writeln(Lst,'ਢ...');
       Close(Lst);
     end;

뢥 ப "ਢ..."  ன⢮ ,    ᨭ⠪
筮  ⠪ ,   ᫨   뢮  䠩.

     ன⢠, ॠ  樮  ⥬  DOS,  -
  筮   뢮.  ࠧ, -
ன⢠  DOS ᯮ 筮  ⥪⮢ 䠩.   ।
    ࠡ   ன⢠ DOS   
ᯮ짮 ⠪ ⨯஢ 䠩.

                        ன⢮ CN


     ன⢮ CN 砥 ᮫, ।⢮ ன 뢮-
 ଠ 뫠  ࠭ ᯫ,   ଠ-
 ਭ  .  ᫨  뫮  ࠢ-
   뢮,  ⠭ 䠩 Input    utput    
䠩,  ᢮ ⮥ , 뫠  ன⢮ CN.

       ன⢠ CN ଠ  筮-ਥ-
஢  ᯮ ।⢠ ।஢ ப, -
  ᠭ  㪮⢥  DOS.   뢠  
ப,    ⠭ ,   ப.

      ⨨  Ctrl+Z   ᨬ    䠩
(end-of-file),  ᫥  ண  㭪  Ef 頥 祭
Tru.
                 ன⢠ LT1, LT2  LT3


      ⢥   ன⢠ 筮  ᪠-
 ᯮ짮   ன  .  ᫨  ᮥ
⮫쪮  ன⢮ ,    筮 뫠,   
ன⢮ LT1.   ⮣ ன⢠   ⠪  ᯮ짮
ᨭ RN.

     筮 ன⢮  -  ன⢮, ।祭-
 ⮫쪮  뢮.    ⪥ ᯮ짮  楤
Reset    䠩,  易     ன,
  ਧ  䠩.

     ⠭  rinter 뢠 ⥪⮢ 䠩  -
६      Lst    ⠭    ன⢮
LT1.  ⮡  뢮 - ଠ樨  襩 ண-
ࠬ  ன⢮ ,     uses 襩 ண-
ࠬ      rinter,      뢮  ᯮ  楤
Writ(Lst,...)  Writln(Lst,...).

           ਬ砭:     ணࠬ Windows ᪠뢠-
       .

                    ன⢠ C1  C2


     㭨樮묨 ⠬ (C1  C2)  ன⢠,
।⠢騥 ᮡ  ᫥⥫ 㭨樮 .
 C1  ᯮ짮 ᨭ AU.

                        ன⢮ NUL


     㫥 ன⢮  (NUL)     
    ਧ  䠩  ⪨ -
뢠  ⮣ ன⢠.   ᫥ ᯮ짮, ᫨  
 ᮧ ⤥ 䠩,    ணࠬ ॡ 㪠
 室  室 䠩.

      饬 砥 ᫥  ᯮ짮 ன  DOS
 Windows  ਬ 㭪樨 -뢮 API Windows. -
 ன⢠,  ⠪  CON,   ࠢ쭮 ࠡ. -
 ன⢠   ࠡ,   १   
⥬,   .  ਬ,  ᫨  ᯮ LPT1, 
ᯥ⪠  뢮, 뢠 㣮  . -
⮬  ᯮ짮 㭪樨 API Windows.

       ன⢠, ।祭  ⥪⮢ 䠩


     ன⢠, ।祭  ⥪⮢ 䠩,  ᯮ-
  ॠ樨 ன,   ন  DOS,   
⮣, ⮡ ᤥ 㯭  ।,  ⫨騩  -
,  ।ᬮ७  筮 ன⢠ DOS. 訬
ਬ஬ ன⢠, ।祭  ⥪⮢ 䠩, -
   CRT,  ॠ   ⠭⭮  Crt.
 ᯥ稢  ନ ⥪⮢ ࠭  -
   ᮧ ਪ ணࠬ  "⠭ --
"  묨 ᨫﬨ,  ᯮ  ⠪  ।⢠,  
梥  .

      ⫨稥  ன DOS,  ன⢠, ।祭 
뢮 ⥪⮢ 䠩,    १ࢨ஢ . -
᪨,     .  ⮣ 䠩 뢠-
  ன⢮   筮 楤 Assign.  ਬ,
⠭  Crt  ॠ  楤  AssignCrt,  
뢠 ⥪⮢ 䠩  ன⢮ CRT.

     ன⢠, ।祭  ⥪⮢ 䠩,  ᯮ-
  ॠ樨 ன,   ন  DOS,   
⮣, ⮡ ᤥ 㯭  ।,  ⫨騩  -
,  ।ᬮ७  筮 ன⢠ DOS. 訬
ਬ஬ ன⢠, ।祭  ⥪⮢ 䠩, -
 ன⢮ CRT,  ॠ   ⠭⭮ 
Crt.   ᭮ 㭪樥    ᯥ祭  䥩  
ᯫ  ன, 筮 ன CN  㫥 Dos.

      ⫨稥  ன DOS,  ன⢠, ।祭 
뢮 ⥪⮢ 䠩,    १ࢨ஢ . -
᪨,     .  ⮣ 䠩 뢠-
  ன⢮   筮 楤  Assign. ਬ,
⠭    Crt  ॠ 楤 AssignCrt,  
뢠 ⥪⮢ 䠩  ன⢮ CRT.

                 뢮    Crt


           ਬ砭:  ࠧ ⭮ ⮫쪮   ணࠬ
      ॠ쭮  饭 ० DOS.

      Crt  ᯮ짮    ᯫ 
 ᮭ쭮  ,   ࠢ ०-
 ࠭,  ७  ,  梥,    㪮
ᨣ.

      Crt  ॠ    ணࠬ,  ।⠢
   ࠢ ।⢠  , ⠪-
,   ࠢ ० ࠭,  ७  ,
梥,  ,  㪮 ᨣ.  Crt  ᯮ짮
⮫쪮   ணࠬ,  ࠡ  ᮭ  IBM
,  AT, S/2  IBM   ᮢ⨬  .

       ᭮ २ ᯮ짮  Crt -
  ᪮    믮 権 ࠡ 
࠭. ணࠬ,  ࠡ騥  㫥 Crt, 뢮  ࠭
ଠ   । 樮 ⥬ DOS,  易-
  ⥫묨 ந⥫묨 ⠬.  ᯮ짮-
   Crt 뢮 ଠ 뫠 ।⢥
  ⥬ -뢮 (IS), ,    
権, ।⢥  .

                   ᯮ짮  CRT


     ⮡ ᯮ짮  Crt,  㦭 㪠  
uses 襩 ணࠬ:

     uses Crt;

      樠樨  Crt  ⮣,  ⮡  뫮 -
  CR,  ⠭ 䠩   뢮 DOS -
 ⠭ 室  室 ⥪⮢ 䠩.   -
⢥ 믮  砫 ணࠬ ᫥ ஢:

     AssignCrt(Input); Reset(Input);
     AssignCrt(Output); Rewrite(Output);

      砥,   ८। 室  室 䠩
  ᪠   ,     䠩  㤥
믮 ⭮ ७祭      ந  室  
⠭⭮   뢮   믮 ஢:

     Assing(Input,''); Reset(Input);
     Assing(Output,''); RewriteOutput);

                            CRT


      Crt ন ,  ,  ⥬  ,  
 ᯮ짮 .  楤 Window   ।-
    -  ࠭ .       
 ᥡ 筮 ⠪,  楫 ࠭.  ⮬ ⠫쭠 
࠭ ⠥ ஭⮩.  㣨 ᫮,   ࠭ 
 .       㤠  ப,
 ⮬  頥  ࠢ    ⨦ -
஬  ப ⥪ த .

      न ࠭,  ஬ ,   ᯮ 
।  ,  ⭮  ⥪饬 .  न ࠭
(1,1) ᮮ⢥  孥 㣫 ࠭.

      㬮砭  ⠥  ࠭.

                      樠 ᨬ


        室 䠩   䠩,   祭 
 Crt, ᯥ樠쭮 祭  ᫥騥 ࠢ騥 ᨬ-
:

Ŀ
                       ᠭ                
Ĵ
   #7            뢠 㪮 ᨣ,  
            BELL        ७ .         
Ĵ
   #8   ஡    .  뢠 -
            BS         ६饭      -
                       . ᫨  㦥 室  -
                           ⥪饣  ,    
                       ⢨  ந.             
Ĵ
   #10  ॢ ப ६頥    ப .
            LF         ᫨  㦥  室    
                       ப  ,     ஫뢠
                          ப.                 
Ĵ
   #13  ⪨ 頥      ⥪-
           BS          饣 .                            


                           ப


      ⥭   室 䠩 (Input)   ⥪⮢ 䠩-
,   祭   Crt,  ⥪      
ப. ப   ७  ⥪⮢ 䠩
  ६ 뢠,   ⢥ 筨 ᯮ-
  .   ࠧ   ⠭ ,  -
  ப.    ப  ᯮ짮 ᫥騥
 ।஢:

Ŀ
 ।஢                ᠭ                
Ĵ
  Backs             ᫥  ᨬ.    
Ĵ
  Es                     ப.           
Ĵ
  Enter                ४頥    ப    뢠
                         ப ( ⪨/-
                       ॢ ப)  .                
Ĵ
  Ctrl+S                ⠪,  Backspace.        
Ĵ
  Ctrl+D                 ᨬ  ᫥ -
                        ப  뢮   ࠭.   
Ĵ
  Ctrl+F               ⠭    ࠭   ᫥
                        ப.                       
Ĵ
  Ctrl+Z               蠥  ப   ᨬ-
                         䠩.                       
Ĵ
  trl-Z                ᨬ  䠩   -
                       蠥 ப .                     


     Ctrl+Z 㤥 ஢  䠩  ⮬ 砥, ᫨ -
६ CheckEOF ⠭  True ( 㬮砭 False).

      ஢ન ﭨ    ⤥ ᨬ
  ࠢ  ணࠬ  ᯮ  㭪樨  Keyressed   
RdKey.

                楤  㭪樨  Crt


Ŀ
㭪/楤              ᠭ                       
Ĵ
  AssignCrt        砥 ⥪⮢  䠩     ன⢠
                   CRT.                                       
Ĵ
  ClrEl           頥   ᨬ,  稭    樨
                       ப,    ६饭
                   .                                   
Ĵ
  ClrScr           頥 ࠭    頥   孥
                    㣫.                                
Ĵ
  Dl            믮 প  㪠 ᫮  -
                   ᥪ㭤.                                  
Ĵ
  DelLine           ப,  ன 室 
                    ६頥  ᫥騥 ப    
                   ப .  ப 頥.     
Ĵ
  GtY           믮 樮஢ .  - ⮳
                   ਧ⠫쭠 ,  Y  -  ⨪쭠
                   .                                   
Ĵ
  ightVideo       롨ࠥ ᨬ  ᢥ⪮.             
Ĵ
  InsLine          ⠢   ப   ᯮ-
                    .                               
Ĵ
  Keyrssd       頥 祭 Tru,  ᫨   
                         Fals  -  ⨢
                   砥.                                    
Ĵ
  LowVid          롨ࠥ ᨬ   મ.    
Ĵ
  NormVideo        롨ࠥ ᨬ  ଠ쭮 મ.    
Ĵ
  NoSound          몫砥 ७ .              
Ĵ
  Sound            砥 ७ .               
Ĵ
  Textckground   롨ࠥ 䮭 梥.                     
Ĵ
  TextColor        롨ࠥ 梥 ᠬ ᨬ.              
Ĵ
  Textd         롨ࠥ  ⥪⮢ ०.       
Ĵ
  Window           ।  ࠭ ⥪⮢ .       
Ĵ
  Rd          뢠 ᨬ  .             
Ĵ
  Wher           頥 न   ⥪饩 樨
                   ,  ⭮    ⥪饬 .  
                   ।⠢ ᮡ  ਧ⠫ .
Ĵ
  WhereY           頥 न Y  ⥪饩 樨
                   ,  ⭮    ⥪饬 .  Y
                   ।⠢ ᮡ ⨪ .   


               ⠭  ६  Crt


      㫥 Crt ᮤন ࠤ ⠭,  ணࠬ-
஢. ஡    뢠    1 "ࠢ筮 㪮-
⢠ ணࠬ". 襬 㯯  ⠭:

Ŀ
    㯯 ⠭                 ᠭ                  
Ĵ
    ⠭ ० Crt     ᪨ ⠭, ᯮ-
                               ⢥ ࠬ஢  -
                              TextMode.                   
Ĵ
    ⠭ 梥⮢         ⠭, ᯮ㥬  -
                              梥⮢     楤
                             TextColor  TextBackGround.      


     ਬ, ⮡  祭 ⠭,    
 뢮 ⥪  ணࠬ  梥⮬,  ᬮ -
⠭ 梥⮢ ⥪   ⠭ Red  祭 4.

      㫥 Crt ᮤঠ ᫥騥 ६:
Ŀ
 ६                       ᠭ                
Ĵ
  CheckBreak        boolean     蠥  頥  -
                                  Ctrl+Break.         
Ĵ
  CheckEof          boolean     蠥   頥 ᨬ-
                                  䠩.             
Ĵ
  CheckSnow         boolean     蠥   頥 -
                                  .             
Ĵ
  DirectVideo       boolean     蠥  頥 - 
                                     - 
                                楤 WriteLn  Write.       
Ĵ
  LastMode          word           맮  TextMode 
                                ࠭  ⥪騩  - 
                                .                         
Ĵ
  TextAttr          byte        ন  ਡ  ⥪饣 
                                ࠭ ⥪.           
Ĵ
  WindMin           word        ন न 孥 
                                 㣫 ⥪饣 .   
Ĵ
  WindMax           word        ন न   
                                ࠢ 㣫 ⥪饣 .  






                   DOS  
-----------------------------------------------------------------------------
 poepa Assign
-----------------------------------------------------------------------------
   㭪: pcaae  eeo aa aoo epeeo.
   Ocae: Assign(var f;  : string)
   pea: apaep f ec aoo  epeeo  oo  ⨯a aa, a
""  oo   peca  coo  paee  cpoooo  ⨯a.  aee
oepa樨 c f  oc c e譨 ao c ee, aa apaepo
"".
   oce opae  poepe Assign c, caoea e epeeo f
 e譨 ao  e  cecoa  o ex op, oa  e  e  oea
pa poepa Assign  epeeo f.
    coco   appa  ( oca), 饣   0   oee 
aaoo, oopx oee p o pa c oo opao oco ep  a
oop묨 cee ec⢨eoe  aa:

   c:\_a\_a\...\_a\_aa

   Ec  oca a稭aec c opao oco ep, o oc a稭aec 
opeo aaoe,  po⨢o cae o a稭aec  ee aaoe.
   "c"  pecae  coo  e䨪aop  ca  (A-Z).  Ec  "c"  
oeoe  oe,  o  coec aae o oa coo.
Kaao "\_a\_a\...\_a"  ec  ope  aaoo  e
oca  oaao,   oopo  coepc  aa. apaep "_aa"
oe  coepa o  oc쬨  coo, a oop묨  o  ceoa oa  
pacpee e aa, o o pex coo.
   Macao oc⨬a a  e aa cocae 79 coo.
   Koa apaep "" pecae coo c cpo, o ec Length()
pao , oae  oco ca. B  o cae apaep  f  oaaec
ca  co  caap ao oa  caap  ao  oa.  
ceae a oo apoa  cpeco  ee apae
oa-oa oepaoo cce OC. Ec  pcoeo  coe  , o oce
opae    Reset(f) f e aa  a  caap a oa, a  oce
opae  Rewrite(f) f e aa a caap a oa.
   Opae: poepa  Assign  e  oa  cooac    opoo
aa.

   pep:  (eaec  oa aa    oa  popa  eco  OC
cpoco PRN, c  ..)

 var f : text;
 begin
   Assign(f,'');                { caap o }
   Rewrite(f);
   Writeln(f,'caap o...');
   Close(f);
 end;

------------------------------------------------------------
 poepa Reset
------------------------------------------------------------
   㭪: Opae cec騩 a.
   Ocae: Reset(var f [ : file; pa_ac : word ] )
   pea:  apaep  f  ec  aoo  epeeo,  cooece
o ⨯ aa. O oe  ca c e譨 ao c oo poep
Assign. apaep  "pa_ac"  pecae  coo eoaeoe paee
o  coo  oe aac oo  o cae, ec f ec e-
oa ao.
   poepa Reset opae cec騩 e譨  a,    oopoo  o
pcoeo f. Ec  e譨  a c aa ee  occe,  o o -
ec o訡o.  Ec a  f e op, o o  caaa apaec, a ae
opaec o. Tea o  ae caaaec a aao aa.
   Ec  f  o  pcoeo  coe    (apep, Assign(f,'')), o  oce
opae    poepe Reset  f  e  cc뫪o  a  caap  a oa
(caap aa 0).
   Ec  f  - eco a, o  o  caoc oc㯭 oo o  e.
oce opae   poepe Reset  Eof(f) pae aee True, ec a
c,  aee False  po⨢o cae.
   Ec  f   ec   e⨯oa   ao,  o  apaep  "pa-ac"
opeee  paep  ac, oop  oe  c-  ooac  p  epeae
ax. Ec o apaep oe, o o opaeaec  pa o oa
128 aa.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.

     pep:
 function FileExists(FileName: string) : boolean;
   { eca 㭪, opaaa aee  True,  ec  a cece 
aee False  po⨢o cae }
 var
   f : file;
 begin
   {$I-}
   Assign(f, FileName);
   Reset(f);
   Close(f);
   {I+}
   FileExists := (IOResult = 0) and (FileName <> '');
 end; { FileExists };
 begin
   if FileExists(ParamStr(1)) then { o  oao cpo  aa }
      Writeln('a cece');
   else Writeln('a e ae');
 end.

------------------------------------------------------------
 poepa Rewrite
------------------------------------------------------------
   㭪: Coae  opae o a.
   Ocae: Rewrite(var f [: file; pa_ac : word ] )
   pea:  apaep  f  ec  aoo  epeeo,  cooece
o ⨯ aa. O oe  ca c e譨 ao c oo poep
Assign. apaep  "pa_ac"  pecae  coo eoaeoe paee
o  coo  oe aac oo  o cae, ec f ec e-
oa ao.
   poepa Rewrite coae o e譨 a,  oo-  poo pcoeo f.
Ec e譨 a c aa ee e cece, o o aec  a eo
ece coaec  o co a.  Ec a  f e op,  o o  caaa
apa-  ec,  a  ae  ᮧ  o.  Tea  o    ae  c-
aaaec a aao ⮣ aa.
   Ec  f  o  pcoeo  coe    (apep, Assign(f,'')), o  oce
opae    poepe  Reset(f)  e  cc뫪o  a caap a  oa
(caap aa oep 1).
   Ec  f  - eco a, o  o  caoc oc㯭 oo o  ac.
oce opae  poepe Rewrite Eof(f) ᥣ pae aee True.
   Ec  f   ec   e⨯oa   ao,  o  apaep  "pa_ac"
opeee  paep  ac, oop  oe  c-  ooac  p  epeae
ax. Ec o apaep oe, o o opaeaec  pa o oa
128 aa.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0   o cae, ec oepa aep訫ac  ceo,  eeo o
o訡  po⨢o cae.

     pep:
 var f : text;
 begin
   Assign(f,'NEWFILE,$$$');
   Rewrite(f);
   Writeln(f,'Coaec a,  oop acaec a
             cpoa');
   Close(f);
 end.

------------------------------------------------------------
 poepa Close
------------------------------------------------------------
   㭪: apae op a.
   Ocae: Close(f)
   pea: apaep f pecae coo  ao  e-  pee  oo
⨯a  aa,  oop    peapeo op c oo  poep  Reset,
Rewrite   Append.  eeo  aa, caoo c epeeo f ooc
oec eo ooee  ae o apaec, oce  eo ao aa
OC  aoo aa ocooaec  oceeo cooa.
   p cooa pe⨢ oopa {$I-} IOResult e opaa 0,
ec  oepa  aep訫ac ceo    e- eo  o  o訡   po⨢o
cae.

   pep:
 var f: file;
 begin
   Assign(f,'\AUTOEXEC.BAT');            { op a }
   Reset(f,1);
   Writeln('Paep aa = ',FileSize);
   Close(f);                             { ap a }
 end.

------------------------------------------------------------
 poepa Read (ecoe a)
------------------------------------------------------------
   㭪: Cae oo  oee  ae   ecoo- o aa   o
 oee epeex.
   Ocae: Read( [ var f : text; ] v1, [, v2,...,vn ] )
   pea: apaep f (ec o aa)  ec  ao-  o  epeeo,
cooece  ecoo   a.   Ec  o  oe,  o  opaeaec
cooae caapo ao-  o epeeo Input. Ka apaep v -
ec epeeo cooo, cpoooo, eoo  eeceoo ⨯a.
   B cae ६ ᨬ쭮 ⨯a poepa  Read  cae    aa
o co  pcaae eo  epeeo.  Ec  epe oee poep
Read 㭪  Eof(f)  paa  aee  True,  o epeeo pcaaec
aee Chr(26) (co Ctrl-Z). Ec  㭪  Eoln(f)  paa  c⨭oe
aee  (True),   o  epeeo  pcaaec  aee  Chr(13)  (co
opaa ape⪨). Cea oepa  Read  aec co ceeo coa 
ae.
   B  cae  epeeo  eoo  ⨯a  poepa  Read  oae  oc㯫e
oceoaeoc coo, opax co co ao, coaco cacc,
aao  paee "ca" a 1 㪮⢠ ணࠬ. e poe,
a a樨  e⪨ oa cpo,  peece  coo  cpo-  e,
pocac.  Cae  pepaaec  p  oape  epoo   poea,
coa  a樨    e⪨  oa  cpo,  oope  ce  a coo
cpoo,   o cae, ec 㭪 Eof(f) pae aee  True. Ec
coa cpoa e cooece oaeo  opa,  o  pocxo  o訡a
oa-oa. B po⨢o cae epeeo pcaaec aee. Ec -
 Eof(f) ea aee True epe oee poep Read,  㭪
Eof(f) pa aee  True p poce aax poeo, ao a-
樨  eo oa cpo, o  epeeo  pcaaec  eoe  aee.
Cea oepa Read aec c poea, coa a樨  e⪨ oa
cpo, oop묨 aep訫ac coa cpoa.
   B cae epeeo eeceoo ⨯a poepa  Read oae oc㯫e
oceoaeoc  coo,   oope   opa  co    cooec⢨  c
cacco, oaa   paee  "ca" a 1 㪮⢠ ணࠬ,
a cee oo, o ecaapoe pecaee  e ocaec. -
e poe, a  a樨  e⪨ oa cpo, peece coo
cpoe, pocac.  Cae  pepa-  aec  p  oape  epoo
poea,  coa  a樨    e⪨  oa  cpo,  oope  ce a
coo cpoo,    o cae,  ec 㭪 Eof(f)  pae aee
True. Ec coa cpoa e cooece oaeo opa, o pocxo
o訡a oa-oa.  B  po⨢o  cae epeeo pcaaec aee.
Ec 㭪 Eof(f) ea aee True epe oee poep Read, 
㭪  Eof(f)  pa  aee  True p poce aax  poe-  o,
ao a樨   eo oa cpo, o epeeo pcaaec eoe
aee. Cea oepa Read  aec  c poea, coa a樨 
e⪨ oa cpo, oop묨 aep訫ac coa cpoa.
   B cae epeeo  cpoooo ⨯a poepa Read cae ce co,
o o cee e⪨  oa cpo (o e a ee),   oa 㭪
Eof(f) e pe ae- e True.  epeeo  pcaaec  o稢ac  
peae  coa  cpoa. Ec a pepe cpo pea-  e
, acao oc⨬  cpooo  epeeo,  o  oa  ceaec.
Cea oepa Read  a稭aec c e⪨ oa cpo, oopo aep訫ac
pea cpoa.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.
   Opae: poepa Read co  cpooo  epeeo e eae oce c-
a   poc    o    cee    cpo.    oo      ca
oceoaeoc  cpo  e  cooa oceoaee opae  
poepe Read, oco  p  o   oa  e epeee ae  epo
cpo. oce epoo opae   poepe  Read  ocee oepa樨 Read
  oap㦨a  e oa cpo  opaa  cpo  eo  .
oo   ca  oceoaeoc  cpo  coe  opae  
poepe Readln.

------------------------------------------------------------
 poepa Read (⨯oae a)
------------------------------------------------------------
   㭪: Cae  epee ee aa.
   Ocae: Read(f, v1 [, v2,...,vn])
   pea:  apaep  f  ec  aoo  epeeo,  cooece
o ⨯  aa, poe ecooo, a  a ee v  pecae coo
epee oo e  ⨯a, o   ee  aa  f. p  ao ca  
epee  ea  o   ae  poaec    cee  ee.
oa  ca  ceeo eea aa  o  oe,  oa  ea
o aa axoc  oe  aa  (o ec oa Eof(f) ee  aee
True) ec o訡o.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.
   Opae: a oe  op.

------------------------------------------------------------
 poepa Readln
------------------------------------------------------------
   㭪: Boe  poep  Read,  ae  epexo   cee cpoe
aa.
   Ocae: Readln( [ var f : text; ] v1 [, v2,...,vn ] )
   pea:  poepa  Readln  ec  pacpee po- ep  Read  
opeeea    ecox ao. oce oe poep Read  poepa
Readln eae poc o aaa cee cpo.
   Bo 㭪樨 Readln(f) e apaepo  po    epe- ee ee
o樨  aa a  aao  cee cpo (ec  oa  eec,   po⨢o
cae  pocxo  epexo     o  aa).  㭪  Readln  e  cca
apaepo ooc cooece opae Readln(Input).
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.
   Opae:  㭪   paoae  oo    ecox  ao,  a
caaap o. a oe  op  oa.

------------------------------------------------------------
 poepa Write (ecoe a)
------------------------------------------------------------
   㭪: acae oo  oee ae  eco a.
   Ocae: Write( [var f : text; ] v1 [, v2,...,vn] )
   pea: apaep f (ec o aa)  ec  ao-  o  epeeo,
cooece  ecoo   a.   Ec  o  oe,  o  opaeaec
cooae caapo ao- o epeeo Output. Ka apaep v -
ec acae-    apaepo.  Ka  acae  apaep  ae
ooe paee, aee oopoo oo  acao  a. 뢠-
 ࠬ ⠪  ᮤঠ ᯥ䨪 ਭ   ⢮ -
 . Kaoe ooe paee oo   cooo, eoo,
eeceoo, cpoooo, aoaoo cpoooo  ecoo ⨯a.
   acae apaep ee :

   o_pa [ : _pa [ : ec_a ]]

   e "o_pa" pecae  coo  ooe paee, a "_pa" 
"ec_a"  c paeﬨ eoo ⨯a.  "_pa" aae a
p  o,  oopa oa  oe .  acaec  poo  coo
coo, coo  opeeeo    apaepe  "_pa"  (p e- oxooc
coc pe  poe),  ᪫祭 砥  "o_pa"
ee aee, oopoe oo  pecaeo co coo, pea騬
aaeoe apaepo "_pa".  B  o cae, o peca aee
"o_pa", acaec ocaooe oeco coo. Aaoo, ec
apaep  "_pa"  oe,   o     oo,  o  peca  aee
"o_pa", acaec ocaooe oeco coo.
   apaep  "ec_a"   aae  co  ecx  ao    pecae
eeceoo ae c 䨪cpoao ao. Oo  oe aac oo
  o cae,  ec  "o_pa" ee eece  ⨯,  a ae  aa
apaep  "_pa".  Ec  apaep  "_pa" aa, o o  oe  
oe   pae .
   o acaec ac cooo ae,  o,  ec  apaep  "_pa"
oe,  a  acaec  cooe paee "o_pa". B po⨢o
cae    ᨬ  aee  apaepa  "o_pa"  㤥  
"_pa" -1 poeo.
   p  ac  eoceoo ae, ec oe apaep "_pa",  o
ecoe pecaee "o_pa" acaec  a e peecx
poe- o.  Ec apaep "_pa" aaec   eo aee  pe- ae
 eco cpo, o epe eco  cpoo acaec oeco
poeo,   ocaooe      oo,   o-    a   eco   cpo
cooecoaa apaep "_pa".
   p  ac   eeceoo   ae,    a  acaec  ecoe
pecaee  eeceoo  ae  "o_pa".  opa  pecae
ac o a  occ⢨ apaepa "ec_a".
   Ec  apaep  "ec_a"  oe  (  ec  o pcce, o  ee
opaeoe aee),  o  acaec  e-  ca  cpoa c aae
ao.  Ec  apaep  "_pa"   ae   oe,  o  o  oa  o
opaeaec pa 17. B po⨢o cae, ec apaep "_pa" ee
8, o  eo aee opaeaec pa  8. eca cpoa  c aae
ao ee ce騩 opa:

   [|-] <pa>.<ec_a>E[+|-<coea>]

   ee oo cpo
------------------------------------------------------------
[|-]              ""  "-" , cooec⢨  a
                  "o-pa"
<pa>           Oea pa  o (⮫쪮
                  oa "o_pa" pao 0).
<ec-a>     poa cpoa o "_pa"-7 (o e
                  oee 10 p).
E                 poco co [E].
[+|-]             a, cooec騩 a coe.
<coea>      eca coea  x p.
------------------------------------------------------------

   Ec pcce apaep "ec_a", o acaec eca cpoa c
䨪cpoao ao. Ec aee  aoo  apaepa peae 11, o oo
caec pa 11. Cpoa c 䨪cpoao ao ee ce騩 opa:

   [<poe>][-]<p>[.<ec_a>]

   ee cpo c 䨪cpoao ao
------------------------------------------------------------
[.<poe>]      poe (o  cpo cooecoa-
                  a apaep "_pa".
[-]               a -, ec "o_pa" opaeo.
<p>           o pae epe oa pa. pe -
                   e  ocac.
<.ec_a>    ece  a, ec apaep "ec_a"
                  oe .
------------------------------------------------------------

   ac ae  cpoooo  ⨯a  pooc  ce騬  opao.  Ec
apaep  "_pa"  oe,  o    a  acaec  cpoooe  aee
"o_pa", a  peece  poe  occ.  Ec aa apaep
"_pa"  eo  aee peae  "o_pa", o epe eco
cpoo    oo, o  ee  a  cooecoaa  apaep  "_pa",
acaec ocaooe oeco poeo.
   p  ac  ae aoaoo cpoooo ⨯a, e  e  e  e
ca, o  p ac cpo, a o- opo cooece c eeo
 pae aoaoo cpoooo ⨯a.
   p  ac  ecoo ae oc ae e  ec⢨,  a  p
ac cpo True  False,  acoc o ae "o_pa".
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.
   Opae: a oe  op  oa.

------------------------------------------------------------
 poepa Write (⨯oae a)
------------------------------------------------------------
   㭪: acae epee  ee aa.
   Ocae: Write(f, v1 [, v2,...,vn] )
   pea: apaep f ec aoo  epeeo,  a  a ee v
pecae coo epee oo e ⨯a, o  ee aa f. p ao
ac epeeo ea o  ae poaec  cee ee.
Ec e-  a o  aa axoc  oe aa  (o ec oa Eof(f)
ee aee True), o a pacpec.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.

------------------------------------------------------------
 poepa Writeln
------------------------------------------------------------
   㭪: Boe poep Write, a ae acae   a e oa
cpo.
   Ocae: Writeln( [ var f : text; ] v1, [, v2,...,vn])
   pea:  aa  poepa ec pacpee po- ep Write  
ecox  ao.   oce   oe  poep  Write  poepa  Writeln
acae e oa cpo (opa ape⪨ / epeo cpo).
   p   oe   ao  poep  e  apaepo  (WriteLn(f)),     a
acaec  ea  oa  cpo.  (poepa Writeln e  aa  cca
apaepo ooc cooece poepe Writeln(Output)).
   Opae: a oe  op  oa.

------------------------------------------------------------
 poepa BlockRead
------------------------------------------------------------
   㭪: Cae o  oee ace  epee.
   Ocae: BlockRead(var f : a; var  ; ce稪 : word [; pea :
word ])
   pea:  apaep  f  pecae  coo  ⨯஢   ao
epee, ""  - a epeea,  "ce稪" paee o  coo 
"pea" - o ae epeea o  coo.
   aa poepa  cae  ac,  oeco  oopx  e  peocxo
ca,  aaoo   epeeo "ce稪",   䠩  f  , a稭a  c
epoo  aa,  aoo  epeeo  "".  ec⢨eoe  co  ox
cax  ace   (eee     paoe  ae  epeeo  "ce稪")
opaaec    eoaeo apaepe "pea". Ec o apaep  e
aa, o  o cae, oa co poax ace e e coaa co
aee epeeo "ce稪", pooe o訡a oa-oa.
   Bec paep  epeaoo  oa  e  peae  ca ao, opeeex
poeee ae epeeo  "ce稪"    ac, aaeo p
op⨨ aa (o oa 128). Ec o poeee peae 65535 (64K
aa), o oae o訡a.
   apaep "pea"  ec  eoae.  O  pao-  ae ce騬
opao. Ec   epea ec o, o p  opae pae  apaepe
"pea" e coepac o e aee, o   epeeo "ce稪". B
po⨢o cae aee apaepa "pea"  e  ee:  o oo, a
cea aepc epeaa,  oape co oa aa. B o cae,
ec  paep  ac  aa  peae  e,  o  apaepe  "pea"
opaaec co  ox  poax  ace.  Ta  opao,  ooa
eoa oce ac e aec  apaepe "pea".
   B  peae  oe poep BlocRead ea o-      ae
poaec a co ace, aax epe- eo "pea".
   p cooa  pe⨢  oopa  {$I-}  㭪  IOResult  e
opaa 0, ec oepa aep訫ac  c-  eo  eeo o o訡  
po⨢o cae.
   Opae: a oe  op.

     pep:

 program CopyFile;
   {   poca   popaa  cpoo  opoa  ao  e  poep   a
ooee o訡o }
 var
   FromF, ToF, : file;
   NumRead, NumWritten : word;
   buf : array[1..2048] of char;
  begin
    Assign(FromF, ParamSrt(1)); { op xoo a }
    Reset(FromF);               { paep ac - 1 }
    Assign(ToF, ParamStr(2));   { op xoo a }
    Rewrite(ToF, 1);            { paep ac = 1 }
    Writeln('Kopoae ',FileSize(FromF),' ao...');
    repeat
      BlockRead(FromF, buf, SizeOf(buf), NumberRead);
      BlockWrite(ToF, buf, NumberRead, NumWritten);
    until (NumRead = 0) or (NumWitten <> NumRead);
     Close(FromF);
     Close(ToF);
  end.

------------------------------------------------------------
 poepa BlockWrite
------------------------------------------------------------
   㭪: acae o  oee ace  epeeo.
   Ocae: BlockWrite(var f : a; var ; ce稪 : word [; pea :
word ])
   pea:  apaep   f   pecae   coo  e⨯oa  ao
epee, ""  - a epeea,  "ce稪" paee o  coo 
"pea" - o ae e- peea o  coo (.e. ee ⨯ word).
   aa  poepa  acae    䠩  f  ac,  oeco  oopx e
peocxo  ca,  aaoo    epeeo "ce稪", a稭a  c  epoo
aa, aoo  epeeo  "".  ec⢨eoe  co ox acax
ace (eee  paoe ae  epeeo  "ce稪")  opaaec  
eoaeo apaepe  "pea". Ec o  apaep e aa, o  o
cae,  oa  co  acax  ace  e  e coaa co  aee
epeeo "ce稪", pooe o訡a oa-oa.
   Bec paep  epeaoo  oa  e  peae  ca ao, opeeex
poeee ae epeeo  "ce稪"    ac, aaeo p
op⨨ aa (o oa 128). Ec o poeee peae 65535 (64K
aa), o oae o訡a.
   apaep "pea"  ec  eoae.  O  pao-  ae ce騬
opao. Ec   epea ec o, o p  opae pae  apaepe
"pea" e coepac o e aee, o   epeeo "ce稪". B
po⨢o cae aee apaepa "pea"  e  ee:  o oo, a
cea aepc epeaa, c epeoc.  B  o  cae, ec paep
ac aa peae e, o   a-  paepe  "pea"  opaaec
co  ox  acax  a-  ce.  Ta   opao,  ooa  eoa
ocaac oce ac e aec  apaepe "pea".
   B  peae  oe  poep  BlockWrite ea o    ae
poaec a co ace, aax e- peeo "pea".
   p cooa pe⨢ oopa {$I-} IOResult e opaa 0,
ec  oepa  aep訫ac ceo    e- eo  o  o訡   po⨢o
cae.
   Opae: a oe  op.

------------------------------------------------------------
 poepa Seek
------------------------------------------------------------
   㭪: epeeae e o  ae  aao ee.
   Ocae: Seek(f, n : longint)
   pea:  apaep   f   ec   o  aoo  epeeo,  poe
ecoo, a n pecae coo paee eo- o ⨯a. Tea  o 
ae f epeeaec    ee c oepo n.  Hoep  epoo eea aa
pae  0.   oo,  o pacp a,  oo  o oc  eea
aa,   pacooeoo    a   oce   eeo.   To   ec   oepaop
Seek(f,FileSize(f)) epeeae e o  ae  o- e aa.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.
   Opae:  poep  e cooa  eco- x ao.  a
oe  op.

------------------------------------------------------------
 㭪 SeekEof
------------------------------------------------------------
   㭪: Bopaae  aa cac "oe aa" (end-of-file).
   Ocae: SeeEof [ (var f : text) ]
   T peaa: ec (boolean).
   pea:  a  cee oo,  o  㭪  SeeEof  pocae  ce
poe, a a樨  e⪨ oa cpo- ,  oa ooc cooece
㭪樨 Eof.  Ee oeo c- ooa  p ca cox  ae 
ecooo aa.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.
   Opae: 㭪 oo cooa oo   ecox ao. a
oe  op.

------------------------------------------------------------
 㭪 SeekEoln
------------------------------------------------------------
   㭪: Bopaae  aa cooﭨe "oe cpo" (end-of-line).
   Ocae: SeekEoln [ (var f : text) ]
   T peaa: ec (boolean).
   pea:  a  cee  oo,  o 㭪 SeeEoln  pocae  ce
poe    a  a樨,  oa ooc cooece 㭪樨  Eoln.  Ee
oeo cooa p ca cox ae  ecooo aa.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0   o cae, ec oepa aep訫ac  ceo,  eeo o
o訡  po⨢o cae.
   Opae: 㭪 oo cooa oo   ecox ao. a
oe  op.

------------------------------------------------------------
 㭪 FilePos
------------------------------------------------------------
   㭪: Bopaae e o  ae.
   Ocae: FilePos(var f)
   T peaa:  e (longint).

   pea: apaep  f  pecae  coo  ao  e- pee. Ec
ee oe  ec  aao  aa,  o  㭪 FilePos(f) opaae
aee 0. Ec  ee  oe   ae ec oe  aa,  o  ec
Eof(f)  opaae   aee   True,   o  aee,  opaaeoe  㭪e
FilePos(f),  coaae  co  aee,   opaae   㭪e  FileSize(f)
(paepo aa).
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.
   Opae: a 㭪 e oe  cooac    ecooo  aa.
a oe  op.

------------------------------------------------------------
 poepa Truncate
------------------------------------------------------------
   㭪: ceae paep aa o ee o樨  ae.
   Ocae: Truncate(var f)
   pea:  apaep  f  ec  aoo epeeo oo  ⨯a.  Bce
ac oce  ee o樨   ae f ac   ea o  ae
caoc oo aa (㭪 Eof(f) pae aee True).
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.
   Opae: a f oe    op.楤 Truncate  ࠡ⠥ 
⥪⮢ 䠩.

------------------------------------------------------------
 poepa Append
------------------------------------------------------------
   㭪: Opae e騩 a  pcoee.
   Ocae: Append(var f : text)
   T peaa: apaep  f - aoa epeea ecooo ⨯a, oopa
oa  caa c e譨 ao c oo poep Assign.
   poepa Append opae cec騩 e譨 a c ee, aae
epeeo f. Ec eeo aa  c  aa ee e cece, o  o
ec o訡o. Ec a f e  op, o o caaa apaec, a ae
opaec aoo. Tea o caaaec a oe aa.
   Ec    ocee  oe  aa paepo 128 ao  pcce  co
Ctrl-Z (26  oe ASCII),  o  ea o caaaec  ae  a
opao, o p ac ep  oe e "apac" co  Ctrl-Z. -
  ࠧ, ⥪     ᮥ   䠩  ࢠ   
Ctrl-Z.
   Ec epeeo f o pcoeo  coe    (apep, Assign(f,''), o
oce opae  poepe Append, f e aa a caap xoo
a (caap aa oep 1).
   oce opae  Append a  f  caoc oc㯭 oo o ac  
㪠⥫ 䠩 㤥 ⠭   䠩.
   p cooa  pe⨢  oopa  {$I-}  㭪  IOResult  e
opaa aee 0 p ceo aepe oepa樨  eeo o o訡
 po⨢o cae.
   pep:
var f : text;
begin
  Assign(f, 'Test.txt');
  Rewrite(f);                { coa o a }
  Writeln(f, 'cxo ec');
  Close(f);          { ap a, coxpa ee }
  Append(f);         { oa ec  oe aa }
  Writeln(f,'ooe ec');
  Close(f);          { ap a, coxpa ee }
end.

------------------------------------------------------------
 㭪 Eof (ecoe a)
------------------------------------------------------------
   㭪: Bopaae cocoﭨe "oe aa"  eco- x ao.
   Ocae: Eof(var f: text)
   T peaa: ec.
   pea: apaep f, ᫨ 筮  㪠,  pecae  coo  ao
epee,  opee  eco a.  Ec  o  apaep  oe,  o
coec  caapa  aoa epeea Input. Ec ea o  
ae  axoc  a oce  eeo  aa   ec  a e  coep
ax eeo, o 㭪 Eof(f)  opaae  aee  True. B po⨢o
cae oa opaae aee False.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.

     pep:
 var
   f  : text;
   ch : char;
  begin  { o  aa  oao cpo }
   Assign(f, ParamStr(1));
   Reset(f);
  while not Eof(f) do
    begin
     Read(f,ch);   { ec eco a }
     Write(ch);
    end;
 end.

------------------------------------------------------------
 㭪 Eof (⨯oae  e⨯oae a)
------------------------------------------------------------
   㭪:   ⨯oax   e⨯oax ao opaae cocoﭨe
"oe aa".
   Ocae: Eof(var f)
   T peaa: ec (boolean).
   pea: apaep  f  pecae  coo  ao  e- pee. Ec
ea o  ae axoc a oce eeo aa   ec a
e coep ax e- eo, o 㭪 Eof(f)  opaae aee True.
B po⨢o cae oa opaae aee False.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.

------------------------------------------------------------
 㭪 Eoln
------------------------------------------------------------
   㭪:  ao opaae cocoﭨe "oe cpo" (end-of-line).
   Ocae: Eoln [ (var f : text) ]
   T peaa: ec (boolean).
   pea: apaep f, ᫨ 筮  㪠,  pecae  coo  ao
epee,  opee  eco a.  Ec  o  apaep  oe,  o
opaeaec  cooae  caapo  aoo epeeo Input.  Ec
ea o   ae axoc a ee oa  cpo, o 㭪 Eoln(f)
opaae aee True. B po⨢o cae oa opaae aee False.
   p poep cocoﭨ "oe cpo"   caapoo oa, apaee
oopoo eeo e  o, cea popaa  e a, oa  e  e
ee co opaa ape⪨, a ae epeac paee 㭪樨 Eoln.

  begin
      WriteLn(Eoln);     { o pee  o, o }
                         { popaa e oa oa }
                         { aap }
    end.

     p  aa  pe⨢  oopa   {$I-}   㭪
IOResult e opaa aee 0  o cae, ec oe-
pa aep訫ac ceo,  eeo o o訡   po⨢-
o cae.

------------------------------------------------------------
 㭪 FileSize
------------------------------------------------------------
   㭪: Bopaae e騩 paep aa.
   Ocae: FileSize(f)
   T peaa:  e (longint).
   pea:  apaep  f pecae coo ao e- pee.  aa
㭪 opaae  co eeo  f.  Ec a c,  㭪 opaae
aee 0.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.
   Opae:  㭪  e oe cooac  ecooo aa,  a
oe  op.

     pep:
 var
   f : file of byte;
 begin
  { o  aa  oao cpo }
  Assign(f, ParamStr(1));
  Reset(f);
  Writeln('Paep aa  aax: ', FileSize(f));
  Close(f);
 end.

------------------------------------------------------------
 poepa FindFirst                             Mo Dos
------------------------------------------------------------
   㭪:  poo  oc    aao ( ee) a-  aoe  epo
ac, cooece aao e aa  aop apo aa.
   Ocae: FindFirst(app: string; ap : te; var S: SearchRec)
   pea: apaep  "app" opeee  aao, apep "*.*".
apaep "ap"  opeee  ee   cco paccapaex ceae
a (ap co ce o묨  aa).  pee  cco apo aa,
a o oca  oe Dos:

  const
    { oca apo aa }
   ReadOnly   = $01;  { oo ee }
   Hidden     = $02;  { "cp" a }
   SysFile    = $04;  { cce a }
   VolumeId   = $08;  { e䨪aop oa }
   Directory  = $10;  { aao }
   Archive    = $20;  { apxa }
   AnyFile    = $3F;  { po稩 a }

   Pea  oca  o   aao   opaaec    aao  ac  ⨯a
SearchRec, oop ocaec  oe Dos:

  type
   { ⨯ SearchRec, co騩c  poepax FindFirst
      FindNext }
    SearchRec = record
                  Fill : array[1..2] of byte;
                  Attr : byte;
                  Time : longint;
                  Size : longint;
                  Name : string[12];
                end;

   Ko o訡 oo o c oo DosError. Boo묨 aeﬨ oo
c 3 (aao e ae)  18 (oe ao e).

     pep:
  uses Dos;
  var
    DirInfo : SearchRec;
  begin
    FindFirst('*.PAS', Archive, DirInfo); { o e, o 
                                            DIR *.PAS }
    while DosError = 0 do
    begin
      Writeln(DirInfo.Name);
      FindNext(DirInfo);
    end;
  end.

------------------------------------------------------------
 poepa FindNext                              Mo Dos
------------------------------------------------------------
   㭪:  Bopaae  ce ac, coaa c ee   apa
aa, aa묨 p pee opae-   poepe FindFirst.
   Ocae: FindNext(var s : SearchRec)
   pea: apaep s oe  a e, a p opae  FindFirst
(⨯ SearchRec ocaec  oe Dos; c. poep  FindFirst). C oo
DosError oo o-  o  o訡.  Eceo  oo oo ec
o 18, aa騩 a occ⢨e ao.

------------------------------------------------------------
 㭪 FSearch                                 Mo Dos
------------------------------------------------------------
   㭪: e a  cce aaoo.
   Ocae: FSearch(app: PathStr; cco_a: string)
    १ : PathStr
   pea: 㭪 oe oc aa, aaoo apaepo "app",
  cce  aaoo,  aax  apaepo "cco_a". Kaao    cce
o  paec oo  c  ao aaoo o,  a  o eaec  
oae oepaoo cce DOS PATH. oc  a稭aec  cea  c  eeo
aaoa  a   ee   ce.   Bopaaeoe  aee  pecae  coo
oaea ooo   appo aaoo  e aa  ,  o cae,
ec a ae e e, c cpo.
   T PathStr oca  oe Dos, a cpoo ⨯ string[79].
    axoe oex ao c oo oa OC PATH 㦭o aa
poep GetEnv('PATH')    epea  pea  㭪樨  FSearch  aece
apaepa "cco_a".
   Pea   㭪樨   FSearch   oo   epea   㭪樨   FExpand   
peopaoa  eo    ooe    aa,  o ec    aa,  acaoe
poc묨  㪢a  aee  ce 㪢e e  cooa    app
oca    aao,  a-  稭a  o  opeoo  aaoa.  Kpoe  oo  
paee e aa a cpo ᪮/aao,    䠩    ७
 䠩 oo cooa 㭪 FSplit.

     pep:
  uses Dos;
  var
    S: PathStr;
  begin
    S: := FSearch('TURBO.EXE', GetEnv('PATH'));
    if S = '' then
       WriteLn('a TURBO.EXE e ae');
    else
       WriteLn('Hae a ',FExpand(S));
  end.

------------------------------------------------------------
 poepa FSplit                                Mo Dos
------------------------------------------------------------
   㭪: Paee  aa a p ooe.
   Ocae: FSplit(app: PathStr; var aao: DirStr;  var : NameStr;
var pacp: ExtStr)
   pea:  aa,  aaoe  apaepo "app", paeec a p
eo ooe.    epeeo "aao" caaaec aee 㪢eo
e⪨ cooa  appa oca  aao co ce aa   oe묨
aa, ࠧ묨  opao  oco  ep, epeeo "" pcaaec
aee  e  aa, a  epeeo  "pacp" -  pacpee  e aa  c
peece oo. Ka  x  cocax  cpo  eeo  oe
oaac c ( o  cae,  ec "app" e coep cooeceo
eea).
   T PathStr, DirStr, ExtStr  NameStr opeee  o- e Dos ce騬
opao:

  type
    PathStr = string[79];
    DirStr  = string[67];
    NameStr = string[8];
    ExtStr  = string[4];

   p  paee  e  aa a ooe  FSplit  e  o-  ae  e
ae  ax  coo    p oaea樨 pe-  px  epeex
"aao", ""  "pacp" e oe aa app.

     pep:
  uses Dos;
  var
    P: PathStr;
    D: DirStr;
    N: NameStr;
    E: ExtStr;
  begin
    Write(' aa (WORK.PAS) : ')
    ReadLn(P);
    FSplit(p, D, N, E);
    if N = '' then N:='WORK';
    if E = '' then E:='.PAS';
    P := D + N + E;
    WriteLn('Pepee  = ',P);
  end.

------------------------------------------------------------
 㭪 FExpand                                 Mo Dos
------------------------------------------------------------
   㭪: Pacpe  aa o ooo e aa.
   Ocae: FExpand(app :PathStr)
   pea: Pacpe    aa,  aaaeoo  apaepo  "app", o
ooo e aa. oeoe   peae    peopaec  poce
㪢    cop   㪢e   e  cooa,  oeoe,    oca
ooceo ope- oo aaoa   aa. Bpee  cc뫪 a aao
".."  "." ac.
   T PathType opeee  oe OC  e cpo (string[79]).
   peoo, o e騬 co  aaoo  ec C:\SOURCE\PAS. Toa
cee o poep FExpand a ae ae:

  FExpand('test.pas')      = 'C:\SOURCE\PAS\TEST.PAS'
  FExpand('../*.TPU')      = 'C:\SOURCE\*.TPU'
  FExpand('c:\bin\turbo.exe') = 'C:\BIN\TURBO.EXE'

   楤 FSplit   ᯮ짮   ࠧ १ 㭪樨
FExpand  ப : ᪮/⠫,  䠩  ७  䠩.

------------------------------------------------------------
 poepa RmDir
------------------------------------------------------------
   㭪: ae co oaao.
   Ocae: RmDir(s : string)
   pea: apaep  s  ec  paee  cpoooo  ⨯a. aec
oaao  c  e  oca,  aa  cpoo  s. Ec    oca  e
cece,  ec  ec    ec  o  aae  e騩  aoo,  o
pocxo o訡a o- a-oa.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.

     pep:
 begin
   {$I-}
   { o  aaoa  oao cpo }
   RmDir(ParamStr(1));
   if IOResult <> 0 then
      Writeln('Kaao a e');
   else
      Writeln('Kaao ae');
 end.
------------------------------------------------------------
 poepa GetDir
------------------------------------------------------------
   㭪: Bopaae e騩 aao a aao ce.
   Ocae: GetDir(d : byte; var s : string)
   pea: apaep  d pecae coo paee e- oo  ⨯a, a s -
epee  cpoooo  ⨯a. aee eeo aaoa a ce,  aaoo
apaepo d, opaaec  epeeo s.  aee d = 0 aae a e-
騩 co- o, 1 - aae coo A, 2 - B  ..
   楤 GetDir  믮 ᠬ஫ 訡
------------------------------------------------------------
 poepa ChDir
------------------------------------------------------------
   㭪: Boe ce eeo aaoa.
   Ocae: ChDir(s : string)
   pea: apaep s pecae coo paee cpoooo ⨯a. Te-
騩  aao  eec   a  o,  oop  aaec  c  oo  appa,
aaoo    apaepe s.  Ec    apaepe  s  aaec  㪢ea ea
cooa, o e騩 coo ae eec.
   p cooa  pe⨢  oopa  {$I-}  㭪  IOResult  e
opaa 0, ec oepa aep訫ac  c-  eo  eeo o o訡  
po⨢o cae.

     pep:
  begin
   {$I-}
  { o  oao cpo  aaoa }
  ChDir(ParamStr(1));
   if IOResult <> 0 then
      Writeln('Kaao e ae');
  end.
------------------------------------------------------------
 poepa MkDir
------------------------------------------------------------
   㭪: Coae oaao.
   Ocae: MkDir(s : string)
   pea: apaep  s  pecae  coo  paee  cpoooo  ⨯a.
Coaec  o  aao  c  e  oca,  aa cpoo s.  oce
ee o ac e oe aaa  ceceo aa.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.

     pep:
 begin
  {$I-}
  { o  oao cpo  aaoa }
   MkDir(ParamStr(1));
   If IOResult <> 0 then
      Writeln('coae aaoa eooo');
   else
      Writeln('coa o aao');
 end.
------------------------------------------------------------
 poepa Erase
------------------------------------------------------------
   㭪: Cpae e譨 a.
   Ocae: Erase(var f)
   pea: apaep f pecae coo  ao  e-  pee  oo
aooo ⨯a. Be譨 a, ca c epeeo f, cpaec.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.
   Opae: poepa Erase e oa cooac  opoo aa.

     pep:
 var
   f : file;
  ch : char;
 begin
  { o  oao cpo  peaaeoo 
   ae aa }
   Assign(f, ParamStr(1));
  {$I-}
   Reset(f);
  {$I+}
   if IOResult <> 0 then
     Write('a e ae ' ParamStr(1))
   else
   begin
      Close();
     Write('Cepe ', ParamStr(1)),'?');
     Readln(ch);
     if UpCase(ch) = 'Y' then
     Erase(f);
  end;
 end.
------------------------------------------------------------
 poepa Rename
------------------------------------------------------------
   㭪: epeeoae e譨 a.
   Ocae: Rename(var f; o_ : string)
   pea:  apaep   f   pecae   coo  ao  e-  pee,
cooec  o   a  oo  ⨯a.  apaep  "o_"  ec
paee  cpoooo  ⨯a. Bee  a,  cao  c  epeeo  f,
pcaaec ooe , a- aoe apaepo "o_". aee oepa樨
c f  oc c e譨 ao c o ee.
   p aa pe⨢ oopa {$I-} 㭪 IOResult e opaa
aee 0  o cae, ec oe- pa aep訫ac ceo,  eeo o
o訡  po⨢o cae.
   Opae: poepa  Rename  e  oa  cooac    opoo
aa.
------------------------------------------------------------
 㭪 DiskFree                              Mo Dos
------------------------------------------------------------

   㭪: Bopaae co coox ao a aao ce.
   Ocae: DiskFree(c: word)
   T peaa:  e (longint).
   pea:  aee  apaepa "c", paoe 0, aae opeee  o
oa c, aee 1 aae a c A, 2  - a  c B   ..  Ec
oep ca eec⢨ee, o aa poepa opaae aee -1.

     pep:
  uses Dos;
  begin
    Writeln('Cooo ',DiskFree(0) div 1024,' oa');
  end.
------------------------------------------------------------
 㭪 DiskSize                              Mo Dos
------------------------------------------------------------
   㭪: Bopaae 饥 co ao a aao ce.
   Ocae: DiskSize(c: word)
   T peaa:  e (longint).
   pea:  aee  apaepa "c", paoe 0, aae opeee  o
oa c, aee 1 aae a c A, 2  - a  c B   ..  Ec
oep ca eec⢨ee, o aa poepa opaae aee -1.

     pep:
 uses Dos;
  begin
    Writeln(DiskSize(0) div 1024,' oa cooo');
  end.
------------------------------------------------------------
 㭪 ParamCount
------------------------------------------------------------
   㭪: Bopaae co apaepo, epeax   oao cpoe.
   Ocae: ParamCount
   T peaa: Coo (word).
   pea: Paeeﬨ ca poe  co a- 樨.

     pep:
 begin
   if ParamCount < 1 then
      Writeln('B oao cpoe e apaepo');
   else
      Writeln(ParamCount,' apaepo');
 end.
------------------------------------------------------------
 㭪 ParamStr
------------------------------------------------------------
   㭪: Bopaae aa apaep oao cpo.
   Ocae: ParaStr(ec)
   T peaa: ப (string).
   pea: apaep "ec" pecae coo paee o  coo.
aa  㭪  opaae   oao  cpo  apaep,  oep  oopoo
aaec apaepo "ec",  c cpo, ec "ec" paec 
 oe, e ParaCount.  ᨥ ⥬ DOS 3.0   , -
 ParamStr(0) 頥    䠩 믮塞 ணࠬ (ਬ,
c:\tp\yprog.exe).

     pep:
 var i : word;
 begin
   for i := 1 to ParamCount do
        Writeln(ParamStr(i));
 end.
------------------------------------------------------------
 poepa SwapVectors                           Mo Dos
------------------------------------------------------------
   㭪: Mee eop 뢠.
   Ocae: SwapVectors
   pea:  ee  coepoe aaee SaveIntXX  oe System  
eee coepoe  eopo  pepa.  poepa  SwapVectors  oo -
aec eocpeceo epe  eocpeceo  oce  oa  Exec.  Ta
opao oece稢aec, o  oe o o Exec poecc e coe
ax opao稪o pea, caoex e騬 poecco  aoopo.

     pep:
        {$M 8192,0,0}
        uses Dos;
        var
          Command: string[79];
        begin
          Write('Bee oa OC:');
          Readln(Command);
          if Command <> '' then
             Command := '/C' + Command;
          Swapvectors;
          Exec(GetEnv('COMSPEC'), Command);
          SvapVectors;
          if DosError <> 0 then
           Writeln('Koa a COMMAND.COM o
                    e');
        end.
------------------------------------------------------------
 poepa Exec                                  Mo Dos
------------------------------------------------------------
   㭪:  Boe  aa  popa,  epeaa  a-  a  cpo
apaepo.
   Ocae: Exec(app, o_cpoa : string)
   pea:  popa aaec   apaepe  "ap-  p", a cpoa
apaepo coepc    apaepe  "o_cpoa".   oe pee
oa OC ace a COMMAND.COM. Hapep:

     Exec('\COMMAND.COM','/C DIR *.PAS');

   /C epe oao  ec apoco a  ac aa COMMAND.COM  (o  e
p㣨x  popa).  Booe o o訡o oo o  c  oo  㭪樨
DosError.  ⨬  oa  o-   2, 8, 10  11. Ko aepe poecca
oo o c oo 㭪樨 DosExitCode.
    뢠  楤  SwapVector  ।⢥    ࠧ
᫥  맮  Exec.  楤  SwapVector  頥  ᮤন  㪠⥫
SaveIntXX   㫥 System   ⥪饥 ﭨ ஢ 뢠.  -
࠭,   Exec  ᯮ   뢠, -
 ⥪騬 ᮬ  .
   o aaa oe  popa poepa Exec e e- e pacpeeee
a. Ta opao, p o樨 popa, coe poep Exec,
eoxoo   oece-      aae   acaoo   paepa   aec
pacpeee- o  oac a, ae a  oe e xa  (DosError =
8).
   ࠭祭: ᨨ  ணࠬ ᯥ祭 ⥬ Novell Network 
࠭, 祬 2.01  2.02  ন 맮  DOS, ᯮ㥬 楤ன
Exec. ᫨  ᯮ ⥣஢ 㦥 IDE  ᪠ ணࠬ,
 ᯮ 楤 Exec,    ࠭ ணࠬ ᯥ祭
⥬  Nowell,   ⠭      祭   樨   (Compile  |
Destination)      ணࠬ  DOS (   ᯮ짮-
  ⮣  File | DOS Shell).

     pep:
 {$4000,0,0 }
 { 16K eec  cea, aec pacpeeea
   oac e apa訢aec  e peeppec }
  uses Dos;
  var
    ProgramName, CmdLine : string;
  begin
    Write('popaa, oop 㦭o o (a
           ooe   oca): ');
    Readln(ProgramName);
    Write('Koaa cpoa, oop 㦭o epea  po-
           pa ', ProgramName, ':');
    Readln(CmdLine);
    Writeln('Haao oe Exec...');
    SwapVectors;
    Exec(ProgramName, CmdLine);
    SwapVectors;
    Writeln('...opa  Exec');
    if DosError <> 0 then                        { o訡a }
       Writeln('O訡a OC #', DosError)
    else
       Writeln('Bo Exec poe ceo. Ko aepe
                opoeoo poecca = ', DosExitCode);
  end.
------------------------------------------------------------
 㭪 DosExitCode                             Mo Dos
------------------------------------------------------------
   㭪: Bopaae  opoecca o aepe.
   Ocae: DosExitCode
   T peaa: Coo (word).
   pea:  Ma訩  a pecae coo o, epe- a  poecco
p aepe. aee capeo aa pao 0 p  opao aepe, 1
- p aepe o a- a  a Ctrl-C, 2 - p aepe -a o訡
cpoca  3 - ec poecc  aepe poepo Keep.
------------------------------------------------------------
 poepa GetDate                               Mo Dos
------------------------------------------------------------
   㭪: Bopaae e a, caoe  oe- paoo ccee.
   Ocae: GetDate(var o, ec, co, e_ee : word)
   pea: Bopaaee  ae  e  cee  aao:  "o"  -
1980..2099,  "ec"  -  1..12,  "co"  1..31,  "e_ee"  -  0..6 (e
aee 0 cooece ocpece).
------------------------------------------------------------
 poepa GetFTime                               Mo Dos
------------------------------------------------------------
   㭪: Bopaae a  pe ocee ac aa.
   Ocae: GetFTime(var f; var pe: Longint)
   pea: apaep  f  oe  pecae  coo ao epee
(cooec ⨯oao,  e⨯o-  ao  ecoo a) 
oopoo oo  oeo pcaae  aoo  epeeo    oop
oe  op. aee pee, opaaeoe  apaepe "pe", oe
 pacaoao e opae   poepe  UnpackTime.  Ko o訡o oo
o c oo  㭪樨 DosError. Ece oo oo o訡 -
ec o 6 (eoc⨬a opaoa aa).
   Opae: a oe  op.
------------------------------------------------------------
 poepa GetTime                               Mo Dos
------------------------------------------------------------
   㭪: Bopaae caoeoe  oepaoo cce- e eee pe.
   Ocae: GetTime(var ac, a, ce㭤a, co_ce : word)
   pea: Bopaaee  apaep  pa cee ae: "ac" -
o 0 o 23, "a" - o 0 o 59, "ce㭤a" -  o 0 o 59  "co_ce" (coa
o ce㭤) - o 0 o 99.
------------------------------------------------------------
 poepa PackTime                              Mo Dos
------------------------------------------------------------
   㭪: peopae  ac  DateTime  (aa    pe)  epexaooe
aee,  peopa    e  ⨯  pecae   a    pee,
coe poepo Set- Time.
   Ocae: PackTime(var DT: DateTime; var Time : longint)
   pea: ac DateTime ocaa  oe Dos ce騬 opao:

 DateTime = record
               Year, Month, Day, Hour, Min, Sec : word;
            end;

    oe ao ac e oec poepa a paoc pa.
------------------------------------------------------------
 poepa UnpackTime                            Mo Dos
------------------------------------------------------------
   㭪:  peopae  epexaooe aee,  pec-  aee  coo
aoa   e  ⨯  pecae  a   pee, opaae
poepa  GetTime,  FindFirst  FindNext,  pacaoa ac  DateTime
(aa  pe).
   Ocae: UnpackTime(६ :longint; var DT : DateTime)
   pea: ac DateTime ocaa  oe Dos ce騬 opao:

       DateTime = record
                   Year, Month, Day, Hour,
                   Min, Sec, : word;
                  end;

    oe ao ac e oec poepa a pa- oc pa.
------------------------------------------------------------
 poepa SetFTime                              Mo Dos
------------------------------------------------------------
   㭪: caaae a  pe ocee ac aa.
   Ocae: SetTime(var f; pe : longint)
   pea: apaep  f  oe   aoo epeeo, cooece
⨯oao,  e⨯oao   ecoo-  a,    
࠭   . apaep "pe" oo  coppoa c oo  opae 
poepe  PackTie.  O訡  oo  o  c  oo  㭪樨  DosError.
Eceo oo  oo  o訡  ec  o  6 (eoc⨬a opaoa
aa).
   Opae: a f oe  op.
------------------------------------------------------------
 poepa SetTime                               Mo Dos
------------------------------------------------------------
   㭪: caaae  oepaoo ccee eee pe.
   Ocae: SetTime(var ac, a, ce㭤a, co_ce : word)
   pea: Bopaaee  apaep  pa cee ae: "ac" -
o 0 o 23, "a" - o 0 o 59, "ce㭤a" -  o 0 o 59  "co_ce" (coa
o ce㭤) - o 0 o 99.
------------------------------------------------------------
 poepa SetDate                               Mo Dos
------------------------------------------------------------
   㭪: caaae e a  oepaoo ccee.
   Ocae: SetDate(var o, ec, co : word)
   pea:  Bopaaee  ae  e cee oc⨬e  ae:
"o"  -  1980..2099, "ec"  -  1..12,  "co"  1..31,  Ec  aa aaa
eepo, o apoc oppec.
------------------------------------------------------------
 poepa GetFAttr                              Mo Dos
------------------------------------------------------------
   㭪: Bopaae ap aa.
   Ocae: GetAttr(var f; var ap : Word)
   pea: apaep  f  oe  peca  coo  ao  epee
(cooec  ⨯oao,  e⨯oao   ecoo a)  
oopoo oo  oeo pcaae aoo epeeo, o oop e
oe    op.  poepa  apo oec e cpae  x  c
aca, aa묨  e oca  oe Dos:

  const
    { oca apo aa }
   ReadOnly   = $01;  { oo ee }
   Hidden     = $02;  { "cp" a }
   SysFile    = $04;  { cce a }
   VolumeId   = $08;  { e䨪aop oa }
   Directory  = $10;  { aao }
   Archive    = $20;  { apxa }
   AnyFile    = $3F;  { po稩 a }

   Ko o訡o oo o  c  oo 㭪樨 DosError. Boo묨 oa
o訡o c o 3 (eoc⨬ ap- p)  o 5 (a eoce).
   Opae: a f e oe  op.

     pep:
 uses Dos;
  var
    f : file;
    attr : word;
  begin
 { o  oao cpo  aa }
 Assign(f, ParamStr(1));
 GetFAttr(f, attr);
 Writeln(ParamStr(1));
 if DosError <> 0 then
    Writeln('Ko o訡 OC = ', DosError)
 else
 begin
    Writeln('Ap = ', attr);
 { opee ⨯ apa aa c oo ao  oe
   Dos }
 if attr and ReadOnly <> 0 then
    Writeln('a oce oo o e');
 if attr and Hidden <> 0 then
    Writeln('"Cp" a');
 if attr and SysFile <> 0 then
    Writeln('Cce a');
 if attr and VolumeId <> 0 then
    Writeln('e䨪aop oa');
 if attr and Directory <> 0 then
    Writeln('Kaao');
 if attr and Archive <> 0 then
    Writeln('Apxpe (o) a');
 end; { else }
end.
------------------------------------------------------------
 㭪 IOResult
------------------------------------------------------------
   㭪: Bopaae  eoe  aee,  pecaee  co-  o  cocoﭨe
ocee oeo oepa樨 oa-oa.
   Ocae: IOResult
   T peaa: Coo (word).
   pea: o  epexa  o訡  oa-oa,  c- o 㭪
IOResult, poepa  oa-oa oa  몫ea (pe⨢a oopa
{$I-}).   Ec   poepa  o-  a-oa  몫ea    pocxo   o訡a
oa-oa,  o,  oa    oc  opaee   㭪樨 IOResult,  ce
ocee oepa樨  oa-oa oppc. Opaee  㭪樨 IOResult
cpacae ee pe a o訡.
   epee opaaex oo o訡o pee    poe  A  㪮⢠
ணࠬ. aee 0 opaae ceoe oee oepa樨 oa-oa.

     pep:
 var
   f : file of byte;
 begin
   { o oa cpo c ee aa }
   Assign(f, ParamStr(1));
   {$I-}
   Reset(f);
   {$I+}
   if IOResult = 0 then
       Writeln('Paep aa  aax :',FileSize(f));
   else
       Writeln('a e ae');
  end.
------------------------------------------------------------
 poepa SetFAttr                              Mo Dos
------------------------------------------------------------
   㭪: Bopaae ap aa.
   Ocae: SetAttr(var f; ap : word)
   pea: apaep  f  oe  pecae  coo ao epee
(cooec ⨯oao,  e⨯o-  ao  ecoo a) 
oopoo oo  oeo pcaae aoo epeeo, o oop e
oe   op.  oppoae  apo  oec  e  oae
cooecx aco, aax  e oca  oe Dos:

   const
    { oca apo aa }
   ReadOnly   = $01;  { oo ee }
   Hidden     = $02;  { "cp" a }
   SysFile    = $04;  { cce a }
   VolumeId   = $08;  { e䨪aop oa }
   Directory  = $10;  { aao }
   Archive    = $20;  { apxa }

   Ko o訡o oo o  c  oo 㭪樨 DosError. Boo묨 oa
o訡o  c  o  3  (eoc⨬  app)   o  5  (oc   a
oep).
   Opae: a e oe  op.

     pep:
 uses Dos;
  var
    f : file;
 begin
   Assign(f,'C:\AUTOEXEC.BAT');
   SetFAttr(f, Hidden);   {-}
   Readln;
   SetFAttr(f, Archive);  {!}
 end.
