home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / OASIS.ZIP / SCL.DOC < prev    next >
Encoding:
Text File  |  1988-09-17  |  18.5 KB  |  634 lines
  1. {$R-,S-,I+,D+,F-,V-,B-,N-,L+ }
  2.  
  3.  
  4. Unit Scl;
  5. Interface
  6.  
  7.  
  8. Uses Dos,Crt;
  9.  
  10. CONST
  11. {************************************************************************}
  12.   Programname  ='OASIS / SCL';
  13.   Version  ='5.0';
  14.   Copyright='Copyright (c)1986,87,88 Eureka Associates';
  15. {************************************************************************}
  16.  
  17. TYPE
  18.   String128    = STRING[128];
  19.   String80     = STRING[80];
  20.   String10     = STRING[10];
  21.   String20     = STRING[20];
  22.   String13     = STRING[13];
  23.   String40     = STRING[40];
  24.   String70     = STRING[70];
  25.  
  26. CONST
  27.  
  28. {Increase the following values if required}
  29.  
  30.   Max_Error_Messages          = 100; {max 100 recs in file ???.ERR}
  31.   Max_Input_Messages          = 400; {max 400 recs in file ???.MSG}
  32.   Max_Heap_Screens            = 20;  {max 20 formats in Mem simultaneously}
  33.  
  34.   Screenfile_Ext : String10     = '.scs';    {Change for other file name}
  35.   Indexfile_Ext  : String10     = '.sci';    {extensions}
  36.   Errorfile_Ext  : String10     = '.err';
  37.   Messagefile_Ext: String10     = '.msg';
  38.  
  39. {Help system }
  40.  
  41.   Code_Help_Field  : INTEGER  = 1060; {F2 Key to display field help screen}
  42.   Code_Help_Format : INTEGER  = 1059; {F1 Key to display format help screen}
  43.   Auto_Help_Set    : BOOLEAN  = TRUE; {Autohelp feature enabled}
  44.   Autohelp_Screen             = 'AUTOHELP'; {Name of autohelp format}
  45.   Maxerrors        : INTEGER  = 3;    {Display Autohelp after 3 consecutive
  46.                                        input errors.}
  47.  
  48. {Country information to be used by SCL; 0=Use System setting. Change if other
  49.  country code is to be used}
  50.  
  51. CONST
  52.   Scl_Country      : INTEGER = 0;
  53.  
  54. {Cursor wrap around feature; Set to TRUE if no wraparound is desired (Mouse) }
  55.  
  56. No_Wrap            : BOOLEAN  = FALSE;{Overrides format specs if TRUE}
  57.  
  58.  
  59. {Field blinker}
  60.  
  61.   Timer_Intervall  : INTEGER  = 3; {Increase for slower blinking fields}
  62.  
  63.  
  64. {Beep Sound}
  65.  
  66.   Beep_Off         : BOOLEAN  = FALSE;    {SCL beeps in case of input errors}
  67.   Beep_Time        : INTEGER  = 3;        {3 bursts of about 50 ms each}
  68.   Beep_Frequency_1 : INTEGER  = 200;      {First frequency  200 hertz}
  69.   Beep_Frequency_2 : INTEGER  = 350;      {Second frequency 350 hertz}
  70.  
  71. (*pointers to the background tasks; inilialized during 'Select_format_file'
  72.  to point to 'dummy' *)
  73.  
  74.   Lp_Background_Pointer:Pointer=NIL;
  75.   Hp_Background_Pointer:Pointer=NIL;
  76.  
  77. {Messages}
  78.  
  79.   Input_Msg_Set    : BOOLEAN  = TRUE;     {Input messages are not supressed}
  80.   Error_Msg_Set    : BOOLEAN  = TRUE;     {error messages are not supressed}
  81.  
  82.  
  83. {**************************************************************************}
  84. { NOTE:
  85.   All constants named 'Code...' define keyboard keys to perform certain
  86.   functions within SCL.
  87.   They are the ASCII Codes of the appropriate keys with 1000 added, if they
  88.   return a two byte (extended) code, starting with an ESC character.
  89.   Example: Code_F7. The F7 key returns a two byte code <ESC> 'A'.
  90.   Therefore it is coded as follows: 1000 + 65 = 1065. (65 is the ASCII Value
  91.   of 'A'.
  92.   (The same scheme applies to all character coding in SCL)
  93. ***************************************************************************}
  94.  
  95. {Characters to be used for the 'Marked field attribute'}
  96.  
  97.   Mark_Field_Left  : INTEGER     = 16; {ASCII 16}
  98.   Mark_Field_Right : INTEGER     = 17; {ASCII 17}
  99.  
  100. {Characters representing 'Yes' and 'No'. Used for boolean variables.
  101.  Change for other languages.}
  102.  
  103.   Code_Yes         : INTEGER  = 89;    {'Y'}
  104.   Code_No          : INTEGER  = 78;    {'N'}
  105.  
  106.  
  107. {Special Keys, change for non standard keyboard layouts}
  108.  
  109.   Code_Cancel_Act  : INTEGER  = 1061;  {F3 to cancel a field change}
  110.   Code_Abort       : INTEGER  = 1068;  {F10 to unconditionally abort a format}
  111.   Code_Escape      : INTEGER  = 27;
  112.   Code_Home        : INTEGER  = 1071;
  113.   Code_Tab         : INTEGER  = 9;
  114.   Code_Ctrltab     : INTEGER  = 1116;  {Internal use, don't change}
  115.   Code_Rtab        : INTEGER  = 1015;
  116.   Code_Return      : INTEGER  = 13;
  117.   Code_Left        : INTEGER  = 1075;
  118.   Code_Right       : INTEGER  = 1077;
  119.   Code_Down        : INTEGER  = 1080;
  120.   Code_Up          : INTEGER  = 1072;
  121.   Code_End         : INTEGER  = 1079;
  122.   Code_Ins         : INTEGER  = 1082;
  123.   Code_Del         : INTEGER  = 1083;
  124.   Code_Backspace   : INTEGER  = 8;
  125.   Code_Pgup        : INTEGER  = 1073;
  126.   Code_Pgdown      : INTEGER  = 1081;
  127.  
  128. {Codes for function keys}
  129.  
  130.   Code_F1          : INTEGER  = 1059;
  131.   Code_F2          : INTEGER  = 1060;
  132.   Code_F3          : INTEGER  = 1061;
  133.   Code_F4          : INTEGER  = 1062;
  134.   Code_F5          : INTEGER  = 1063;
  135.   Code_F6          : INTEGER  = 1064;
  136.   Code_F7          : INTEGER  = 1065;
  137.   Code_F8          : INTEGER  = 1066;
  138.   Code_F9          : INTEGER  = 1067;
  139.   Code_F10         : INTEGER  = 1068;
  140.  
  141. {'Do nothing' character. Don't change.}
  142.  
  143.   Code_Noop                   = 255;
  144.  
  145.  
  146. {Permitted characters for the different types of variables}
  147.  
  148.   Anything_Set     : SET OF BYTE = [1..6,8,14..27,32..254];
  149.   Integer_Set      : SET OF BYTE = [32,43,45,48..57];
  150.   Real_Set         : SET OF BYTE = [32,43,45,46,48..57];
  151.   Alpha_Set        : SET OF BYTE = [32,65..90,97..122,128..167];
  152.  
  153.  
  154. {Message to be displayed in case of fatal SCL error, change for other language}
  155.  
  156.   Fatal_Msg_1                 = 'FATAL ERROR IN SCREENHANDLER: ';
  157.   Fatal_Msg_2                 = 'ERROR NR: ';
  158.   Fatal_Msg_3                 = 'PROGRAM ABORTED.';
  159.  
  160.  
  161. {SCL internal Flags}
  162.  
  163.   Format_Aborted   : BOOLEAN  = FALSE;
  164.   Msgfile_Exists   : BOOLEAN  = FALSE;
  165.   Field_Inverted   : BOOLEAN  = TRUE;
  166.   Blink_Count      : INTEGER  = 0;
  167.   Beep_Switch      : BOOLEAN  = TRUE;
  168.   Beep_Count       : INTEGER  = 0;
  169.  
  170. {System dependant info. Don't change}
  171.  
  172.   Minint           : INTEGER  = -32767;
  173.   Max_Format_Width            = 80;  {Max chars per line}
  174.   Max_Format_Height           = 25;  {Max lines on display}
  175.   Key_Buffer_Size             = 50;  {Type ahead buffer size}
  176.   Max_Format_Fields           = 50;  {Max 50 fields on a format}
  177.   Space            : CHAR     = ' '; {That's what a space looks like}
  178.   Save_Exitproc    : Pointer  = NIL;
  179.  
  180. TYPE
  181.  
  182.   Msgrec       = String70;
  183.   Fieldkinds   = (Variable,Textfield,Constant);
  184.   Contkinds    = (I,R,Alpha,Anything,Bool);
  185.   Position     = (Left,Right,Center);
  186.   Line         = STRING[Max_Format_Width];
  187.   Tenfunctions = ARRAY[1..10] OF BOOLEAN;
  188.   Tenchars     = ARRAY[1..10] OF INTEGER;
  189.   Linearray    = ARRAY[1..Max_Format_Height] OF Line;
  190.   Inputbuffer  = ARRAY[0..Key_Buffer_Size] OF INTEGER;
  191.   Displaytypes = (Mda, Cga, Ega, Mcga, Vga);
  192.  
  193.  
  194.   Fieldrec     = RECORD
  195.                   Field_Msg_Nr           :INTEGER; {ptr to rec in *.msg}
  196.                   Field_Help_Screen      :String10;{help screen for this field}
  197.                   Fx,                    {column where this field starts}
  198.                   Fy,                    {row of this field}
  199.                   Fl                     :BYTE; {field length}
  200.                   Ld_Char                :CHAR; {the char for left delimiter}
  201.                   Rd_Char                :CHAR; {char for right delimiter}
  202.                   Next_Tab,              {the field to go to if tab is pressed}
  203.                   Prev_Tab,              {the field to go to if rtab is pressed}
  204.                   Look_Norm,             {char attribute byte}
  205.                   Look_Act_Color,        {char attribute byte}
  206.                   Look_Act_Mono,         {special coding, see above}
  207.                   Look_Sel_Color,        {char attribute byte}
  208.                   Look_Sel_Mono          :BYTE;
  209.                   Inp_Required           :BOOLEAN;
  210.                   Field_Type             :Fieldkinds;
  211.                   Fill_Char              :CHAR;
  212.                   Check_Each_Char        :BOOLEAN;
  213.                   Cont_Type              :Contkinds;
  214.                   Justify                :Position;
  215.                   Cont_Min,
  216.                   Cont_Max               :REAL;
  217.                   Nr_Of_Dec,
  218.                   Group_First,
  219.                   Group_Last             :BYTE;
  220.                   Selected,
  221.                   Highlighted            :BOOLEAN;
  222.                 END;
  223.   Fieldarray   = ARRAY[1..Max_Format_Fields] OF Fieldrec;
  224.   Screen       = RECORD
  225.                   Format_Status          :BYTE;
  226.                   Screenname             :String10;
  227.                   Format_Help_Screen     :String10;
  228.                   F_Int                  :Tenfunctions;
  229.                   Char_Int               :Tenchars;
  230.                   Error_Field,
  231.                   Message_Field,
  232.                   Total_Fields,
  233.                   First_Tab,
  234.                   Last_Tab,
  235.                   Format_Width,
  236.                   Format_Height          :BYTE;
  237.                   Abort_Ok,
  238.                   Wrap_Ok                :BOOLEAN;
  239.                   Spare                  :BOOLEAN;
  240.                   Format_Color           :BYTE;
  241.                   Format_Image           :Linearray;
  242.                   Field                  :Fieldarray;
  243.                   Filler                 :ARRAY[1..119] OF BYTE; {to get to 36*
  244.                                                                   128 bytes}
  245.                 END;
  246.  
  247.   Sckeyrec      = RECORD
  248.                    Deleted               :BOOLEAN;
  249.                    Scname                :String10;
  250.                    Sckey                 :INTEGER;
  251.                  END;
  252.   Screcptrtyp   = ^heapscreenrec;
  253.   Scstackrec    = RECORD
  254.                    Saved_Mx,
  255.                    Saved_My,
  256.                    Saved_Fn,
  257.                    Saved_Xoff,
  258.                    Saved_Yoff,
  259.                    Recovery_Left,
  260.                    Recovery_Right,
  261.                    Recovery_Top,
  262.                    Recovery_Bottom,
  263.                    Saved_Status,
  264.                    Saved_Char_Code,
  265.                    Saved_Err             :INTEGER;
  266.                    Saved_Fcs             :String80;
  267.                    Saved_Char_Image      :CHAR;
  268.                    Saved_Editmode,
  269.                    Saved_Char_Interrupt,
  270.                    Saved_Fieldend,
  271.                    Format_End            :BOOLEAN;
  272.                    Screc                 :Screcptrtyp;
  273.                  END;
  274.   Heapscreenrec  = Screen;
  275.   Scstacktyp     = ARRAY[1..Max_Heap_Screens] OF Scstackrec;
  276.   Msgptr         = ^msg;
  277.   Msg            = String70;
  278.  
  279. VAR
  280.   Country,                            {contains country code used}
  281.   Date_Format   :INTEGER;             {0=mmddyy, 1=ddmmyy}
  282.   Date_Separator:CHAR;                {from country info}
  283.   Time_Separator:CHAR;                {from country info}
  284.   Currency      :String10;            {from country info}
  285.   Flicker       :BOOLEAN;             {CGA ; needs Snow suppression}
  286.   Screen_Mode   :BYTE;                {IBM Screen mode}
  287.   Screenbase    :Word;                {Base address of video mem}
  288.  
  289.   {above info is set during SCL init and can be inquired anytime}
  290.  
  291.  
  292.   Old_Clock     : Pointer;
  293.   Glb_Regs      : Registers;
  294.   Spaces        : String80;
  295.   Scmsg         : ARRAY [1..500] OF Msgptr;
  296.   Errorfile     : TEXT;
  297.   Msgfile       : FILE OF Msgrec;
  298.   Stack         : Scstacktyp;
  299.   Keyrec        : Sckeyrec;
  300.   Active_Format,
  301.   Active_Field  : INTEGER;
  302.   Screens       : FILE;
  303.   Screenindex   : FILE OF Sckeyrec;
  304.   Inbuff        : Inputbuffer;
  305.   Buffbot,
  306.   Bufftop       : INTEGER;
  307.   Editmode,
  308.   {Mono_Adapter,}
  309.   Fieldend      : BOOLEAN;
  310.   Progpath      : String80;
  311.   Stack_Debth,
  312.   Xoff,
  313.   Yoff,
  314.   Activeformat,
  315.   R_Ptr,
  316.   W_Ptr,
  317.   S_Ptr,
  318.   Scmsgnr,
  319.   Errorcount    : INTEGER;
  320.   Char_Image    : CHAR;
  321.   Char_Code,
  322.   Mx,
  323.   My,
  324.   Glb_Status,
  325.   Glb_Error     : INTEGER;
  326.   Error_Msg_Present,
  327.   Msg_Present   : BOOLEAN;
  328.   Fieldcontsave : String80;
  329.   Active_Format_File
  330.                 : String10;
  331.   Checkrequired,
  332.   Glb_Ok,
  333.   User_Function,
  334.   Begin_Of_Field,
  335.   End_Of_Field,
  336.   End_Of_Format : BOOLEAN;
  337.   Newtime       : REAL;
  338.   Lasterror     : INTEGER;
  339.  
  340.   Screen_Color_Translation_Table: ARRAY[0..255] OF BYTE;
  341.   Current_Screen_Page           :BYTE ABSOLUTE $000:$462;
  342.  
  343. TYPE
  344.   Cursoraddr=RECORD
  345.                 X,Y:BYTE;
  346.              END;
  347.  
  348.   Carray=ARRAY[0..7] OF Cursoraddr;
  349.  
  350. VAR
  351.   Cursorpos:Carray ABSOLUTE $000:$450;
  352.  
  353.  
  354.  
  355. (*Datacom related Declarations*)
  356.  
  357. CONST
  358.   Dc_Parity      : CHAR    = 'E';
  359.   Dc_Stopbits    : INTEGER = 1;
  360.   Dc_Speed       : INTEGER = 9600;
  361.   Dc_Charsize    : INTEGER = 7;
  362.   Dc_Int_Save    : Pointer = NIL;
  363.   Dc_Buffer_Size           = 2100;
  364.   Dc_Rx_Buff_Bottom:INTEGER= 0;
  365.   Dc_Rx_Buff_Top : INTEGER = 0;
  366.   Dc_Open        : BOOLEAN = FALSE;
  367.   Tx_Char_Timeout: INTEGER = 500;
  368.   Rts_Cts_Timeout: INTEGER = 500;
  369.   Rts_Holdover   : INTEGER = 0;
  370.   Rts_Cts_Delay  : INTEGER = 30;
  371.   Bcc_Set        : BOOLEAN = TRUE;
  372.  
  373. (*Datacom Control Characters*)
  374.  
  375.   Nul                      = $0;
  376.   Soh                      = $1;
  377.   Stx                      = $2;
  378.   Etx                      = $3;
  379.   Eot                      = $4;
  380.   Enq                      = $5;
  381.   Ack                      = $6;
  382.   Bel                      = $7;
  383.   CON                      = $7;
  384.   Bs                       = $8;
  385.   Ht                       = $9;
  386.   Lf                       = $a;
  387.   Vt                       = $b;
  388.   Ff                       = $c;
  389.   Cr                       = $d;
  390.   S0                       = $e;
  391.   S1                       = $f;
  392.   Dle                      = $10;
  393.   Dc1                      = $11;
  394.   Dc2                      = $12;
  395.   Dc3                      = $13;
  396.   Dc4                      = $14;
  397.   Nak                      = $15;
  398.   Syn                      = $16;
  399.   Etb                      = $17;
  400.   Can                      = $18;
  401.   Em                       = $19;
  402.   Sub                      = $1a;
  403.   Esc                      = $1b;
  404.   Fs                       = $1c;
  405.   Gs                       = $1d;
  406.   Rs                       = $1e;
  407.   Us                       = $1f;
  408.   Pol                      = $70;
  409.   Sel                      = $71;
  410.   Fsl                      = $73;
  411.   Bsl                      = $74;
  412.   Del                      = $7f;
  413.  
  414.  
  415. (*Datacom Receive Buffer*)
  416.  
  417. VAR
  418.   Dc_Rx_Buffer   : ARRAY[0..Dc_Buffer_Size] OF BYTE;
  419.   Bcc            : BYTE;
  420.  
  421.  
  422.  
  423. PROCEDURE Reset_Screen_Colors;
  424.  
  425. PROCEDURE Change_Color(Att,Newatt:BYTE);
  426.  
  427. FUNCTION Get_Current_Color(Attr:BYTE):BYTE;
  428.  
  429. FUNCTION Capital(Wstr: STRING): STRING;
  430.  
  431. FUNCTION Stripleft(Wstr: STRING): STRING;
  432.  
  433. FUNCTION Stripright(Wstr: STRING): STRING;
  434.  
  435. PROCEDURE Strip(VAR Wstr:STRING;VAR Len:INTEGER);
  436.  
  437. FUNCTION Charstring(Whatchar:CHAR;Len:INTEGER):STRING;
  438.  
  439. PROCEDURE Ftab(VAR Wstr:STRING;Fill_Char:CHAR;Just:Position;Len:INTEGER);
  440.  
  441. FUNCTION Justify_Left(STR:STRING;Len:INTEGER):STRING;
  442.  
  443. FUNCTION Justify_Right(STR:STRING;Len:INTEGER):STRING;
  444.  
  445. FUNCTION Justify_Center(STR:STRING;Len:INTEGER):STRING;
  446.  
  447. PROCEDURE Frontstring(STR:STRING;VAR Head,Tail:STRING);
  448.  
  449. FUNCTION X_Max:INTEGER;
  450.  
  451. FUNCTION Y_Max:INTEGER;
  452.  
  453. FUNCTION St(I:INTEGER):String80;
  454.  
  455. FUNCTION Nr(St:String80):INTEGER;
  456.  
  457. FUNCTION Rst(R:REAL; Decimals:INTEGER):String80;
  458.  
  459. FUNCTION Rnr(S:STRING):REAL;
  460.  
  461. FUNCTION Power(Mantissa, Exponent:REAL):REAL;
  462.  
  463. PROCEDURE Get_Screen_Mode;
  464.  
  465. PROCEDURE Get_Country;
  466.  
  467. PROCEDURE Cursor(Top,Bottom:BYTE);
  468.  
  469. PROCEDURE Cursor_Off;
  470.  
  471. PROCEDURE Scl_Init_Fields;
  472.  
  473. PROCEDURE Set_Edit_Mode(Yes:BOOLEAN);
  474.  
  475. PROCEDURE Writeta(Txt:STRING;X,Y,Attr:BYTE);
  476.  
  477. PROCEDURE Writet(Txt:STRING;X,Y:BYTE);
  478.  
  479. PROCEDURE Writea(Count:Word;X,Y,Attr:BYTE);
  480.  
  481. FUNCTION  Displaytype:Displaytypes;
  482.  
  483. FUNCTION  Videomode:BYTE;
  484.  
  485. PROCEDURE Set_Screen_Color(Color:BYTE);
  486.  
  487. PROCEDURE Set_Field_Color(Fieldnr:INTEGER;Color:BYTE);
  488.  
  489. PROCEDURE Scl_Undraw_Marks(Fieldnr:INTEGER);
  490.  
  491. PROCEDURE Scl_Prepare_Stack;
  492.  
  493. FUNCTION Format_Name:String80;
  494.  
  495. FUNCTION Get_Att(X,Y:BYTE):BYTE;
  496.  
  497. PROCEDURE Paint_Format_Frame(Color:BYTE);
  498.  
  499. PROCEDURE Set_Mx(Value:INTEGER);
  500.  
  501. PROCEDURE Set_My(Value:INTEGER);
  502.  
  503. FUNCTION Exist(Fn : String80):BOOLEAN;
  504.  
  505. FUNCTION Date_String(Y,M,D:Word):String10;
  506.  
  507. FUNCTION Time_String(H,M,S:Word):String10;
  508.  
  509. PROCEDURE Check_Time(VAR Time_Str:String10;VAR H,M,S:Word);
  510.  
  511. PROCEDURE Check_Date(VAR Date_Str:String10;VAR Y,M,D:Word);
  512.  
  513. FUNCTION Weekday(Y,M,D:Word):Word;
  514.  
  515. FUNCTION Julian_Date(VAR Y,M,D:Word):REAL;
  516.  
  517. PROCEDURE Normal_Date(Julian:REAL;VAR Y,M,D:Word);
  518.  
  519. FUNCTION Date:String10;
  520.  
  521. FUNCTION Time(Seconds:BOOLEAN):String10;
  522.  
  523. FUNCTION Environment(Env_Name:String128):String128;
  524.  
  525. PROCEDURE EXECUTE(Progstring:String128);
  526.  
  527. PROCEDURE Executedos(Command:String128);
  528.  
  529. FUNCTION Printer_Ready(Res:BYTE):BOOLEAN;
  530.  
  531. FUNCTION Next_Char(VAR Esc:BOOLEAN):CHAR;
  532.  
  533. FUNCTION Rtime:REAL;
  534.  
  535. PROCEDURE Beep;
  536.  
  537. PROCEDURE Fatal_Scl_Error(Errornr:INTEGER);
  538.  
  539. PROCEDURE W_Crt(Fieldnr:INTEGER;Msg:String80);
  540.  
  541. FUNCTION Sys_Msg(Nr:INTEGER):String80;
  542.  
  543. FUNCTION User_Msg(Nr:INTEGER):String80;
  544.  
  545. PROCEDURE Input_Error(Msgnr:INTEGER);
  546.  
  547. PROCEDURE W_Field_Msg(Fn:INTEGER);
  548.  
  549. PROCEDURE Update_Field(Fieldnr:INTEGER;Fill:BOOLEAN);
  550.  
  551. PROCEDURE R_Cont(Fieldnr:INTEGER;VAR Contents:String80);
  552.  
  553. PROCEDURE R_Sel(Fieldnr:INTEGER; VAR Sel:BOOLEAN);
  554.  
  555. FUNCTION G_Cont(Fn:INTEGER):String80;
  556.  
  557. FUNCTION Scl_G_Cont(Fn:INTEGER):String80;
  558.  
  559. FUNCTION G_Sel(Fn:INTEGER):BOOLEAN;
  560.  
  561. FUNCTION Scl_G_Sel(Fn:INTEGER):BOOLEAN;
  562.  
  563. PROCEDURE Set_Field_Norm(Fieldnr:INTEGER);
  564.  
  565. PROCEDURE Set_Field_Act(Fieldnr:INTEGER);
  566.  
  567. PROCEDURE Finish_Format(Check:BOOLEAN);
  568.  
  569. PROCEDURE Close_Formats;
  570.  
  571. PROCEDURE Select_Format_File(Filename:String10);
  572.  
  573. PROCEDURE Blank_Format;
  574.  
  575. PROCEDURE Select_Format(Fname:String10);
  576.  
  577. PROCEDURE Get_Next_Char(VAR Charnumber:INTEGER ; VAR Inputchar:CHAR);
  578.  
  579. PROCEDURE W_Cont(Fieldnr:INTEGER;Cont:String80);
  580.  
  581. PROCEDURE W_Sel(Fieldnr:INTEGER;Sel:BOOLEAN);
  582.  
  583. PROCEDURE C_Cont(Fieldnr:INTEGER);
  584.  
  585. FUNCTION Format_Done:BOOLEAN;
  586.  
  587. PROCEDURE Goto_Field(Fn:INTEGER);
  588.  
  589. PROCEDURE Display_Format(Xoffset,Yoffset:INTEGER);
  590.  
  591. PROCEDURE Handle_Format;
  592.  
  593. (*   --------Datacom Routines-----------   *)
  594. PROCEDURE Clear_Rx_Buffer;
  595.  
  596. PROCEDURE Set_Dc_Params;
  597.  
  598. PROCEDURE Get_Dc_Status(VAR Status:INTEGER);
  599.  
  600. PROCEDURE Dc_Break;
  601.  
  602. FUNCTION Cts:BOOLEAN;
  603.  
  604. FUNCTION Dsr:BOOLEAN;
  605.  
  606. FUNCTION Ri:BOOLEAN;
  607.  
  608. PROCEDURE Set_Rts(On:BOOLEAN);
  609.  
  610. PROCEDURE Set_Dtr(On:BOOLEAN);
  611.  
  612. PROCEDURE Enable_Port;
  613.  
  614. PROCEDURE Disable_Port;
  615.  
  616. PROCEDURE Dc_Diagnose(On:BOOLEAN);
  617.  
  618. PROCEDURE Close_Dc;
  619.  
  620. PROCEDURE Open_Dc(VAR Result:INTEGER);
  621.  
  622. PROCEDURE Dc_Write(Code:BYTE;VAR Ok:BOOLEAN);
  623.  
  624. FUNCTION Tx_Ok:BOOLEAN;
  625.  
  626. PROCEDURE Send_Char(Code:BYTE;VAR Ok:BOOLEAN);
  627.  
  628. PROCEDURE Send_String(Data:STRING;VAR Ok:BOOLEAN);
  629.  
  630. PROCEDURE Send_Buffer(VAR Tx_Buff;Buff_Start,Buff_Length,Bcc_Add:INTEGER;
  631.                                        Head:STRING;VAR Ok:BOOLEAN);
  632. PROCEDURE Receive_Char(VAR Code:INTEGER;VAR Ok:BOOLEAN);
  633.  
  634.