			  Standard Proc/Funcs

-------------------------------------------------------------------------------
{ $02 } function RdInt: integer;

        Stack: { } -> { i }

-------------------------------------------------------------------------------
{ $03 } function RdCard: cardinal;

        Stack: { } -> { c }

-------------------------------------------------------------------------------
{ $04 } function RdLong: longint;

        Stack: { } -> { li }

-------------------------------------------------------------------------------
{ $05 } procedure WrLwrd(L: LongWord; Width: integer);
	begin write(L: Width); end;

	Stack: { Width, L } -> { }

-------------------------------------------------------------------------------
{ $06 } function RdReal: real;

        Stack: { } -> { r }

-------------------------------------------------------------------------------
{ $08 } function RdChar: char;

        Stack: { } -> { ch }

-------------------------------------------------------------------------------
{ $09 } procedure RdStr(var s: string);

        Stack: { sz, ^s } -> {  }

-------------------------------------------------------------------------------
{ $0a } function EOLN: boolean;

        Stack: { } -> { b }

-------------------------------------------------------------------------------
{ $0b } procedure RdLn;

        Stack: { } -> { }

-------------------------------------------------------------------------------
{ $0c } procedure WrInt(I: Integer; Width: integer);
	begin write(I: Width); end;

	Stack: { Width, I } -> { }

-------------------------------------------------------------------------------
{ $0d } procedure WrCard(C: Cardinal; Width: integer);
	begin write(C: Width); end;

	Stack: { Width, C } -> { }

-------------------------------------------------------------------------------
{ $0e } procedure WrLong(L: LongInt; Width: integer);
	begin write(L: Width); end;

	Stack: { Width, L } -> { }

-------------------------------------------------------------------------------
{ $0f } procedure WrWord(w: word; Width: integer; ndigits: word {= 2/4});

        Stack: { ndigits, Width, w } -> { }

-------------------------------------------------------------------------------
{ $10 } procedure WrReal(r: real; width, fraction: integer);

        Stack: { fraction, width, r } -> { }

-------------------------------------------------------------------------------
{ $12 } procedure WrChr(ch: char; Width: integer);
	begin write(ch: Width); end;

	Stack: { Width, ch } -> { }

-------------------------------------------------------------------------------
{ $13 } procedure WrStr(const s: string; Width: integer);
	begin write(s: Width); end;

	Stack: { Width, addr(s) } -> { }

-------------------------------------------------------------------------------
{ $14 } procedure WrPack(const Buff: packed array [0..Size-1] of char;
		 Width, Size: integer);
	begin write(Buff: Width); end;

	Stack: { Size, Width, addr(Buff) } -> { }

-------------------------------------------------------------------------------
{ $15 } procedure WrLine;
	begin writeln; end;

	Stack: { } -> { }

-------------------------------------------------------------------------------
{ $16 } function fRdInt(var f): integer;

        Stack: { f } -> { i }

-------------------------------------------------------------------------------
{ $17 } function RdCard(var f): cardinal;

        Stack: { f } -> { c }

-------------------------------------------------------------------------------
{ $18 } function RdLong(var f): longint;

        Stack: { f } -> { li }

-------------------------------------------------------------------------------
{ $19 } procedure fWrLwrd(var f; L: LongWord; Width: integer);
	begin write(f, L: Width); end;

        Stack: { Width, L, ^f } -> { ^f }

-------------------------------------------------------------------------------
{ $1a } function fRdReal(var f): real;

        Stack: { f } -> { r }

-------------------------------------------------------------------------------
{ $1c } function fRdChar(var f): char;

        Stack: { ^f } -> { ch }

-------------------------------------------------------------------------------
{ $1d } procedure fRdStr(var f; var s: string);

        Stack: { sz, ^s, ^f } -> {  }

-------------------------------------------------------------------------------
{ $1e } function fEOLN: boolean;

        Stack: { ^f } -> { b }

-------------------------------------------------------------------------------
{ $1f } procedure fRdLn;

        Stack: { ^f } -> { }

-------------------------------------------------------------------------------
{ $20 } procedure fWrInt(var f: text; I: Integer; Width: integer);
	begin write(f, I: Width); end;

	Stack: { Width, I, addr(f) } -> { addr(f) }

-------------------------------------------------------------------------------
{ $21 } procedure fWrCard(var f: text; C: Cardinal; Width: integer);
	begin write(f, C: Width); end;

	Stack: { Width, C, addr(f) } -> { addr(f) }

-------------------------------------------------------------------------------
{ $22 } procedure fWrLong(var f: text; L: LongInt; Width: integer);
	begin write(f, L: Width); end;

	Stack: { Width, L, addr(f) } -> { addr(f) }

-------------------------------------------------------------------------------
{ $23 } procedure fWrWord(var f; w:word; Width:integer; ndigits:word {= 2/4});

        Stack: { ndigits, Width, w, f } -> { f }

-------------------------------------------------------------------------------
{ $24 } procedure fWrReal(var f; r: real; width, fraction: integer);

        Stack: { fraction, width, r, ^f } -> { ^f }

-------------------------------------------------------------------------------
{ $26 } procedure fWrChr(var f: file; ch: char; Width: integer);
	begin write(f, ch: Width); end;

	Stack: { Width, ch, addr(f) } -> { addr(f) }

-------------------------------------------------------------------------------
{ $27 } procedure fWrStr(var f: file; const s: string; Width: integer);
	begin write(f, s: Width); end;

	Stack: { Width, addr(s), addr(f) } -> { addr(f) }

-------------------------------------------------------------------------------
{ $28 } procedure fWrPack(var f: text;
			  const Buff: packed array [0..Size-1] of char;
			  Width, Size: integer);
	begin write(f, Buff: Width); end;

	Stack: { Size, Width, addr(Buff), addr(f) } -> { addr(f) }

-------------------------------------------------------------------------------
{ $29 } procedure fWrLine(var f: text);
	begin writeln(f); end;

	Stack: { addr(f) } -> { }

-------------------------------------------------------------------------------
{ $2a } procedure Finit(var f: file; RecSize: Cardinal;
			Kind: (Normal, Packed, text, file));
	begin
	   initialize file pointed at by <file>
	   with record size <RecSize> and
	   <Kind> = 0 - normal, 1 - packed, 2 - text, 3 - file
	   {         }
	         0 - file, 1 - normal, 2 - text
	end;

	Stack: { Kind, RecSize, addr(f) } -> { }

------------------------------------------------------------------------------
{ $2b } procedure Fopen(var f: file; const Name: string; mode: word);
	begin
	   open file pointed at by <file>
           if ^name = nil   reset(f)    
 	    Open file with required mode = Hi(mode) send to UniDOS as Bregister
 	    Lo(mode): ABCDEFGH
 			 |||\|__ Write/Read mode
 			 |||____ append (  1  Write = 1 )
 			 ||_____ temporary
 			 |______ create new file only
	end;

	Stack: { mode, ^name, ^f } -> { }

-------------------------------------------------------------------------------
{ $2c } procedure: Fclose(var f: file; mode: (FromCompiler,
                                              FromClose,
                                              TruncateClose,
                                              TruncOnly));
	Stack: { mode, ^f } -> { }

-------------------------------------------------------------------------------
{ $2d } function EOF: boolean;
        begin return(eof); end;

        Stack: { } -> { b }

-------------------------------------------------------------------------------
{ $2e } function fEOF(var f): boolean;
        begin return(eof(f)); end;

	Stack: { ^f } -> { b }

-------------------------------------------------------------------------------
{ $2f } procedure EndWr;
        generated at the end of every WRITE (but not WRITELN) procedure

	Stack: { } -> { }

-------------------------------------------------------------------------------
{ $30 } procedure fEndWr;
        generated at the end of every WRITE (but not WRITELN) procedure

	Stack: { } -> { }

-------------------------------------------------------------------------------
{ $31 } procedure BlockRW(var f: file; var Buff; Offset, Nbytes: Cardinal;
 		          var Processed: word; Write: boolean);
	begin
        if processed <> nil then
          if write then
            blockwrite(f, buff[offset], Nbytes, processed^)
          else
            blockread(f, buff[offset], Nbytes, processed^)
        else
          if write then
            blockwrite(f, buff[offset], Nbytes)
          else
            blockread(f, buff[offset], Nbytes);
        end;

        Stack     { RW, addrP, Nbytes, Offset, AddrBuff, f } -> { }

-------------------------------------------------------------------------------
{ $32 } function Fpos(var f): longint;
        begin return(FilePos(f)); end;

        Stack: { f } -> { L }

-------------------------------------------------------------------------------
{ $33 } procedure Seek(var f; pos: longint);
        begin seek(f, pos) end;

        Stack: { L, f } -> { }

-------------------------------------------------------------------------------
{ $34 } function ParamCnt: Cardinal;
	begin return(ParamCnt); end;

	Stack: { } -> { w }

-------------------------------------------------------------------------------
{ $35 } procedure ParamStr(No: Natural; var s: string);
	begin s:= ParamStr(No); end;

	Stack: { sz, addr(s), w } -> { }

-------------------------------------------------------------------------------
{ $36 } function MsgLmt: Natural;
	begin return(ScreenSize(X)) end;

	Stack: { } -> { w }

-------------------------------------------------------------------------------
{ $37 } procedure Remove(const name: string);

        Stack: { ^name } -> { }

-------------------------------------------------------------------------------
{ $38 } function Fsize(var f): longint;
        begin return(FileSize(f)); end;

        Stack: { f } -> { L }

-------------------------------------------------------------------------------
{ $39 } procedure StdPut(var f; const buffer);

        Stack: { ^buffer, f } -> { }

-------------------------------------------------------------------------------
{ $3a } procedure StdGet(var f; var buffer);

        Stack: { ^buffer, f } -> { }

-------------------------------------------------------------------------------
{ $3b } procedure Rename(const old, new: string);

        Stack: { ^new, ^old } -> { }

-------------------------------------------------------------------------------


			   Standard Proc/Funcs

   
    .0 /.8  .1 /.9  .2 /.a  .3 /.b  .4 /.c  .5 /.d  .6 /.e  .7 /.f 

00                 RdInt   RdCard  RdLong  WrLwrd  RdReal         07

08 RdChar  RdStr   Eoln    RdLn    WrInt   WrCard  WrLong  WrWord 0f

10 WrReal           WrChr  WrStr   WrPack  WrLine  fRdInt  fRdCard17

18 fRdLong fWrLwrd fRdReal         fRdChr  fRdStr  fEoln   fRdLn  1f

20 fWrInt  fWrCard fWrLong fWrWord fWrReal         fWrChr  fWrStr 27

28 fWrPack fWrLine  Finit  Fopen   Fclose  EOF     fEOF    EndWr  2f

30 fEndWr BlockRW  Fpos    seek   ParamCntParamStr MsgLmt  Remove 37

38 Fsize   StdPut  StdGet  Rename                                 3f

    .0 /.8  .1 /.9  .2 /.a  .3 /.b  .4 /.c  .5 /.d  .6 /.e  .7 /.f 
   