home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / msdos / pibterm / pibt41s1.arc / GETSCRIP.MOD < prev    next >
Encoding:
Text File  |  1988-03-22  |  35.1 KB  |  920 lines
  1. (*----------------------------------------------------------------------*)
  2. (*        Get_Script_Command --- Get command from script buffer         *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. PROCEDURE Get_Script_Command( VAR Command : PibTerm_Command_Type );
  6.  
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*       Procedure:   Get_Script_Command                                *)
  10. (*                                                                      *)
  11. (*       Purpose:     Get command from script buffer                    *)
  12. (*                                                                      *)
  13. (*       Calling Sequence:                                              *)
  14. (*                                                                      *)
  15. (*          Get_Script_Command( VAR Command : PibTerm_Command_Type );   *)
  16. (*                                                                      *)
  17. (*             Command --- command extracted from buffer                *)
  18. (*                                                                      *)
  19. (*----------------------------------------------------------------------*)
  20.  
  21. VAR
  22.    I          : INTEGER;
  23.    L          : INTEGER;
  24.    Ch         : CHAR;
  25.    IBogus     : LONGINT;
  26.    LBogus     : LONGINT;
  27.    Key_Offset : INTEGER;
  28.    Section_No : INTEGER;
  29.    IVal       : LONGINT;
  30.    VPtrs      : Script_Variable_List_Ptr;
  31.  
  32. (*----------------------------------------------------------------------*)
  33. (*   Copy_Script_String --- Copy a string from the script buffer        *)
  34. (*----------------------------------------------------------------------*)
  35.  
  36. PROCEDURE Copy_Script_String( VAR S: AnyStr; VAR V: LONGINT );
  37.  
  38. (*----------------------------------------------------------------------*)
  39. (*                                                                      *)
  40. (*     Remarks:                                                         *)
  41. (*                                                                      *)
  42. (*        Each string is stored in the form:                            *)
  43. (*                                                                      *)
  44. (*           String_Type    1 byte                                      *)
  45. (*           String_Length  1 byte                                      *)
  46. (*           Text           String_Length bytes                         *)
  47. (*                                                                      *)
  48. (*       The values for String_Type are:                                *)
  49. (*                                                                      *)
  50. (*           0  --- ordinary string, text follows                       *)
  51. (*           1  --- use 'localreply' text                               *)
  52. (*           2  --- use 'remotereply' text                              *)
  53. (*           3  --- use 'set' variable -- String_length is index        *)
  54. (*                                                                      *)
  55. (*       String_Length and Text are stored when String_Type = 0.        *)
  56. (*       Neither is stored for types 1 and 2.  String_Length =          *)
  57. (*       variable index is stored for type 3.                           *)
  58. (*                                                                      *)
  59. (*----------------------------------------------------------------------*)
  60.  
  61. VAR
  62.   L : INTEGER;
  63.  
  64. BEGIN (* Copy_Script_String *)
  65.                                    (* Pick up string type *)
  66.  
  67.    INC( Script_Buffer_Pos );
  68.    V := Script_Buffer^[Script_Buffer_Pos];
  69.  
  70.                                    (* Get string value based upon type *)
  71.    CASE V OF
  72.  
  73.       0:  BEGIN (* Text string *)
  74.  
  75.              INC( Script_Buffer_Pos );
  76.  
  77.              L := Script_Buffer^[Script_Buffer_Pos];
  78.  
  79.                                    (* Watch out -- direct move here! *)
  80.  
  81.              MOVE( Script_Buffer^[Script_Buffer_Pos + 1], S[1], L );
  82.  
  83.              S[0] := CHR( L );
  84.  
  85.              Script_Buffer_Pos := Script_Buffer_Pos + L;
  86. {
  87.              IF Debug_Mode THEN
  88.                 WRITELN('---> String length = ',L,', string = <',S,'>');
  89. }
  90.           END;
  91.  
  92.       1:  BEGIN (* Local reply string *)
  93.              S := Script_Reply;
  94.           END;
  95.  
  96.       2:  BEGIN (* Remote reply string *)
  97.              S := Script_Remote_Reply;
  98.           END;
  99.  
  100.       3:  BEGIN (* Script variable *)
  101.              INC( Script_Buffer_Pos );
  102.              V := Script_Buffer^[Script_Buffer_Pos];
  103.              S := Script_Variables^[V].Var_Value^;
  104. {
  105.              IF Debug_Mode THEN
  106.                 WRITELN('---> Script variable ',V,' has value <',S,'>');
  107. }
  108.           END   (* Script variable *);
  109.  
  110.       ELSE
  111.           S    := '';
  112.           V    := 4;
  113. {
  114.           IF Debug_Mode THEN
  115.              WRITELN('---> BOGUS STRING MODE = ',V,' in Copy_Script_String.');
  116. }
  117.    END (* CASE *);
  118.  
  119. END   (* Copy_Script_String *);
  120.  
  121. (*----------------------------------------------------------------------*)
  122. (*   Copy_Script_Integer --- Copy an integer from the script buffer     *)
  123. (*----------------------------------------------------------------------*)
  124.  
  125. PROCEDURE Copy_Script_Integer( VAR IntVal: LONGINT;
  126.                                VAR V     : LONGINT );
  127.  
  128. (*----------------------------------------------------------------------*)
  129. (*                                                                      *)
  130. (*     Remarks:                                                         *)
  131. (*                                                                      *)
  132. (*        Each integer is stored in the form:                           *)
  133. (*                                                                      *)
  134. (*           Integer_Type    1 byte                                     *)
  135. (*           Integer_Value   4 bytes (if Integer_Type=0)                *)
  136. (*                                                                      *)
  137. (*       The values for Integer_Type are:                               *)
  138. (*                                                                      *)
  139. (*           0  --- integer constant (four bytes) follows               *)
  140. (*           n  --- use variable "n"                                    *)
  141. (*                                                                      *)
  142. (*----------------------------------------------------------------------*)
  143.  
  144. BEGIN (* Copy_Script_Integer *)
  145.  
  146.    INC( Script_Buffer_Pos );
  147.    V := Script_Buffer^[Script_Buffer_Pos];
  148.  
  149.    IF ( V = 0 ) THEN
  150.       BEGIN
  151.          MOVE( Script_Buffer^[Script_Buffer_Pos + 1 ], IntVal, SIZEOF( LONGINT ) );
  152.          INC( Script_Buffer_Pos , SIZEOF( LONGINT ) );
  153.       END
  154.    ELSE
  155.       MOVE( Script_Variables^[V].Var_Value^[1], IntVal, SIZEOF( LONGINT ) );
  156.  
  157. END   (* Copy_Script_Integer *);
  158.  
  159. (*----------------------------------------------------------------------*)
  160. (*   Copy_Script_Integer_Constant --- Copy integer cosntant from script *)
  161. (*----------------------------------------------------------------------*)
  162.  
  163. PROCEDURE Copy_Script_Integer_Constant( VAR IntVal: LONGINT );
  164.  
  165. BEGIN (* Copy_Script_Integer_Constant *)
  166.  
  167.    MOVE( Script_Buffer^[Script_Buffer_Pos + 1 ], IntVal, SIZEOF( LONGINT ) );
  168.  
  169.    INC( Script_Buffer_Pos , 4 );
  170.  
  171. END   (* Copy_Script_Integer_Constant *);
  172.  
  173. (*----------------------------------------------------------------------*)
  174. (*   Get_Transfer_Protocol --- Get file transfer protocol               *)
  175. (*----------------------------------------------------------------------*)
  176.  
  177. PROCEDURE Get_Transfer_Protocol;
  178.  
  179. VAR
  180.    I     : INTEGER;
  181.    Found : BOOLEAN;
  182.    TName : Char_2;
  183.    TType : Transfer_Type;
  184.  
  185. BEGIN (* Get_Transfer_Protocol *)
  186.  
  187.    Found := FALSE;
  188.                                    (* Pick up transfer type name *)
  189.    TName := '  ';
  190.    TType := None;
  191.  
  192.    FOR I := 1 TO MIN( 2 , LENGTH( Script_String_2 ) ) DO
  193.       TName[I] := UpCase( Script_String_2[I] );
  194.  
  195.                                    (* Look up transfer name *)
  196.  
  197.    FOR I := 1 TO ( Max_Transfer_Types - 1 ) DO
  198.       IF ( TName = Trans_Type_Name[Transfers[I]] ) THEN
  199.          BEGIN
  200.             TType := Transfers[I];
  201.             Found := TRUE;
  202.          END;
  203.                                    (* Didn't find it -- check special *)
  204.                                    (* Kermit names.                   *)
  205.    IF ( NOT Found ) THEN
  206.       IF ( TName = 'K ' ) THEN
  207.          TType := Kermit
  208.       ELSE IF ( TName = 'KA' ) THEN
  209.          BEGIN
  210.             TType := Kermit;
  211.             Kermit_File_Type_Var := Kermit_Ascii;
  212.          END
  213.       ELSE IF ( TName = 'KB' ) THEN
  214.          BEGIN
  215.             TType := Kermit;
  216.             Kermit_File_Type_Var := Kermit_Binary;
  217.          END;
  218.                                    (* Assume default type if none given *)
  219.    IF ( TType = None ) THEN
  220.       TType := Default_Transfer_Type;
  221.  
  222.                                    (* Record transfer type *)
  223.  
  224.    Script_Integer_1 := ORD( TType ) + 1;
  225.  
  226. END   (* Get_Transfer_Protocol *);
  227.  
  228. (*----------------------------------------------------------------------*)
  229. (*          Fix_Wait_Time --- Fix up time to wait for WAIT* commands    *)
  230. (*----------------------------------------------------------------------*)
  231.  
  232. PROCEDURE Fix_Wait_Time;
  233.  
  234. BEGIN (* Fix_Wait_Time *)
  235.  
  236.    IF ( Script_Wait_Time <= 0 ) THEN
  237.       Script_Wait_Time := Script_Default_Wait_Time;
  238.  
  239.    IF ( Script_Wait_Time <= 0 ) THEN
  240.       Script_Wait_Time := 30;
  241.  
  242.    Really_Wait_String := TRUE;
  243.  
  244.    Script_Wait_Start  := TimeOfDay;
  245.    Script_Wait_Found  := FALSE;
  246.  
  247.    Command            := Null_Command;
  248.  
  249. END   (* Fix_Wait_Time *);
  250.  
  251. (*----------------------------------------------------------------------*)
  252. (*          Get_WaitList --- Get stuff for WaitList command execution   *)
  253. (*----------------------------------------------------------------------*)
  254.  
  255. PROCEDURE Get_WaitList;
  256.  
  257. VAR
  258.    I     : INTEGER;
  259.    QDoit : BOOLEAN;
  260.  
  261. CONST
  262.    LongIntZero : STRING[4] = ^@^@^@^@;
  263.  
  264. BEGIN (* Get_WaitList *)
  265.                                    (* Get result variable index *)
  266.  
  267.    Copy_Script_Integer( LBogus , Script_Wait_Result_Index );
  268.  
  269.                                    (* Zero out result index *)
  270.  
  271.    Script_Variables^[Script_Wait_Result_Index].Var_Value^ := LongIntZero;
  272.  
  273.                                    (* Get # of strings *)
  274.  
  275.    INC( Script_Buffer_Pos );
  276.    Script_Wait_Count        := Script_Buffer^[Script_Buffer_Pos];
  277.    Script_Wait_Check_Length := 0;
  278.    QDoit                    := TRUE;
  279.  
  280.                                    (* Set up vector of wait strings *)
  281.  
  282.    FOR I := 1 TO Script_Wait_Count DO
  283.       WITH Script_Wait_List[I] DO
  284.          BEGIN
  285.             NEW( Wait_Text );
  286.             IF ( Wait_Text <> NIL ) THEN
  287.                BEGIN
  288.                   Copy_Script_String( Wait_Text^ , IBogus );
  289.                   Wait_Text^ := Read_Ctrls( Wait_Text^ );
  290.                END
  291.             ELSE
  292.                BEGIN
  293.                   QDoit := FALSE;
  294.                   Copy_Script_String( Script_String , IBogus );
  295.                END;
  296.             IF QDoit THEN
  297.                BEGIN
  298.                   NEW( Wait_Reply );
  299.                   IF ( Wait_Reply <> NIL ) THEN
  300.                      BEGIN
  301.                         Wait_Reply^  := '';
  302.                         Script_Wait_Check_Length := MAX( Script_Wait_Check_Length ,
  303.                                                          LENGTH( Wait_Text^ ) );
  304.                      END
  305.                   ELSE
  306.                      QDoit := FALSE;
  307.                END;
  308.          END;
  309.  
  310.    Copy_Script_Integer_Constant( Script_Wait_Failure );
  311.  
  312.    IF QDoit THEN
  313.       BEGIN
  314.  
  315.          WaitString_Mode := ( ( Script_Wait_Count > 0 ) AND
  316.                               ( Script_Wait_Check_Length > 0 ) );
  317.  
  318.                                    (* Get wait time *)
  319.  
  320.          Script_Wait_Time := Script_Default_Wait_Time;
  321.  
  322.          Fix_Wait_Time;
  323.  
  324.       END
  325.    ELSE
  326.       BEGIN
  327.          WaitString_Mode := FALSE;
  328.          Command         := Null_Command;
  329.       END;
  330.  
  331. END   (* Get_WaitList *);
  332.  
  333. (*----------------------------------------------------------------------*)
  334. (*     Get_WaitString --- Get stuff for WaitString command execution    *)
  335. (*----------------------------------------------------------------------*)
  336.  
  337. PROCEDURE Get_WaitString;
  338.  
  339. VAR
  340.    QDoit : BOOLEAN;
  341.  
  342. BEGIN (* Get_WaitString *)
  343.  
  344.    Copy_Script_String ( Script_String    , IBogus );
  345.    Copy_Script_String ( Script_String_2  , IBogus );
  346.    Copy_Script_Integer( Script_Wait_Time , IBogus );
  347.  
  348.                                    (* No result index *)
  349.    Script_Wait_Result_Index := 0;
  350.    QDoit                    := TRUE;
  351.  
  352.                                    (* If waitstring null, skip this guy *)
  353.  
  354.    IF ( LENGTH( Script_String ) = 0 ) THEN
  355.       BEGIN
  356.          WaitString_Mode   := FALSE;
  357.          Script_Wait_Count := 0;
  358.       END
  359.    ELSE
  360.       BEGIN
  361.                                    (* One waitstring *)
  362.          Script_Wait_Count := 1;
  363.          WaitString_Mode   := TRUE;
  364.  
  365.          WITH Script_Wait_List[1] DO
  366.             BEGIN
  367.                NEW( Wait_Text );
  368.                IF ( Wait_Text <> NIL ) THEN
  369.                   Wait_Text^ := Read_Ctrls( Script_String )
  370.                ELSE
  371.                   QDoit := FALSE;
  372.                IF QDoit THEN
  373.                   BEGIN
  374.                      NEW( Wait_Reply );
  375.                      IF ( Wait_Reply <> NIL ) THEN
  376.                         BEGIN
  377.                            Wait_Reply^ := Read_Ctrls( Script_String_2 );
  378.                            Script_Wait_Check_Length := LENGTH( Script_String );
  379.                         END
  380.                      ELSE
  381.                         QDoit := FALSE;
  382.                   END;
  383.             END;
  384.                                    (* Fix up wait time *)
  385.          IF QDoit THEN
  386.             Fix_Wait_Time;
  387.  
  388.       END;
  389.  
  390.    Copy_Script_Integer_Constant( Script_Wait_Failure );
  391.  
  392.    IF ( NOT QDoit ) THEN
  393.       BEGIN
  394.          WaitString_Mode   := FALSE;
  395.          Script_Wait_Count := 0;
  396.       END;
  397.  
  398. END   (* Get_WaitString *);
  399.  
  400. (*----------------------------------------------------------------------*)
  401. (*                Get_Menu --- Get stuff for MENU command               *)
  402. (*----------------------------------------------------------------------*)
  403.  
  404. PROCEDURE Get_Menu;
  405.  
  406. VAR
  407.    Default : INTEGER;
  408.    Row     : INTEGER;
  409.    Col     : INTEGER;
  410.    LRow    : LONGINT;
  411.    LCol    : LONGINT;
  412.    LDefault: LONGINT;
  413.    NItems  : INTEGER;
  414.    Items   : INTEGER;
  415.  
  416. BEGIN (* Get_Menu *)
  417.                                    (* Result variable index *)
  418.  
  419.    Copy_Script_Integer( LBogus , Script_Integer_1 );
  420.  
  421.                                    (* Display position *)
  422.  
  423.    Copy_Script_Integer( LCol   , IBogus );
  424.    Copy_Script_Integer( LRow   , IBogus );
  425.  
  426.    Row := LRow;
  427.    Col := LCol;
  428.                                    (* Default *)
  429.  
  430.    Copy_Script_Integer( LDefault , IBogus );
  431.  
  432.    Default := LDefault;
  433.                                    (* Get menu title *)
  434.  
  435.    Copy_Script_String( Script_String , IBogus );
  436.  
  437.                                    (* Get # of items *)
  438.  
  439.    INC( Script_Buffer_Pos );
  440.    NItems := Script_Buffer^[Script_Buffer_Pos];
  441.  
  442.                                    (* Generate the menu *)
  443.    NEW( Script_Menu_Holder );
  444.  
  445.    IF ( Script_Menu_Holder <> NIL ) THEN
  446.       BEGIN
  447.  
  448.          Make_A_Menu( Script_Menu_Holder^, NItems, Row, Col, 0, 0, Default,
  449.                       Script_String, '', FALSE );
  450.  
  451.                                    (* Get and store item strings *)
  452.          FOR Items := 1 TO NItems DO
  453.             Copy_Script_String( Script_Menu_Holder^.Menu_Entries[Items].Menu_Item_Text ,
  454.                                 IBogus );
  455.  
  456.       END
  457.    ELSE
  458.       BEGIN
  459.          FOR Items := 1 TO NItems DO
  460.             Copy_Script_String( Script_String , IBogus );
  461.          Command := Null_Command;
  462.       END;
  463.  
  464. END   (* Get_Menu *);
  465.  
  466. (*----------------------------------------------------------------------*)
  467. (*                Locate_Var --- Locate variable                        *)
  468. (*----------------------------------------------------------------------*)
  469.  
  470. FUNCTION Locate_Var(     VPtrs  : Script_Variable_List_Ptr;
  471.                          VCount : INTEGER;
  472.                          VName  : AnyStr;
  473.                      VAR VType  : ShortStr;
  474.                      VAR Value  : AnyStr     ) : INTEGER;
  475.  
  476. VAR
  477.    I    : INTEGER;
  478.    IVal : LONGINT;
  479.  
  480. BEGIN (* Locate_Var *)
  481.  
  482.    VType      := 'UNDEFINED';
  483.    Value      := '';
  484.    Locate_Var := 0;
  485.    VName      := UpperCase( VName );
  486.  
  487.    FOR I := VCount DOWNTO 2 DO
  488.       IF ( VName = VPtrs^[I].Var_Name ) THEN
  489.          BEGIN
  490.             CASE VPtrs^[I].Var_Type OF
  491.                Integer_Variable_Type : BEGIN
  492.                                           VType := 'INTEGER';
  493.                                           MOVE( VPtrs^[I].Var_Value^[1],
  494.                                                 IVal, SIZEOF( LONGINT ) );
  495.                                           STR( IVal , Value );
  496.                                        END;
  497.                String_Variable_Type  : BEGIN
  498.                                           VType := 'STRING';
  499.                                           Value := VPtrs^[I].Var_Value^;
  500.                                        END;
  501.             END (* CASE *);
  502.             Locate_Var := I;
  503.             EXIT;
  504.          END;
  505.  
  506. END   (* Locate_Var *);
  507.  
  508. (*----------------------------------------------------------------------*)
  509.  
  510. BEGIN (* Get_Script_Command *)
  511.                                    (* Check for suspended script      *)
  512.                                    (* and exit if suspension still    *)
  513.                                    (* in progress.                    *)
  514.  
  515.    IF ( Script_Suspend_Time > 0 ) THEN
  516.       IF ( TimeDiffH( Script_Suspend_Start, TimeOfDayH ) <=
  517.          Script_Suspend_Time ) THEN
  518.             BEGIN
  519.                Command := Null_Command;
  520.                EXIT;
  521.             END
  522.       ELSE
  523.          Script_Suspend_Time := 0;
  524.  
  525.                                    (* Set script strings to null      *)
  526.    Script_String    := '';
  527.    Script_String_2  := '';
  528.    Script_Integer_1 := 0;
  529.                                    (* Point to next command in buffer *)
  530.  
  531.    INC( Script_Buffer_Pos );
  532.  
  533.                                    (* Pick up command type            *)
  534.  
  535.    Command   := PibTerm_Command_Table_2[ Script_Buffer^[Script_Buffer_Pos] ];
  536.  
  537.                                    (* For commands with arguments,     *)
  538.                                    (* get the arguments.               *)
  539.  
  540.    CASE Command Of
  541.  
  542.        DelaySy    : BEGIN
  543.                        Copy_Script_Integer( Script_Integer_1 , IBogus );
  544.                        Delay_Time := Script_Integer_1 * 100;
  545.                     END;
  546.  
  547.        SuspendSy  : BEGIN
  548.                        Copy_Script_Integer( Script_Integer_1 , IBogus );
  549.                        Script_Suspend_Time  := Script_Integer_1;
  550.                        Script_Suspend_Time  := Script_Suspend_Time * 10;
  551.                        Script_Suspend_Start := TimeOfDayH;
  552.                        Command              := Null_Command;
  553.                     END;
  554.  
  555.        QuitSy     : Copy_Script_Integer_Constant( Script_Integer_1 );
  556.  
  557.        ChdirSy    : BEGIN
  558.                        Copy_Script_String( Script_String , IBogus );
  559.                        IVal := POS( ':' , Script_String );
  560.                        IF ( IVal > 0 ) THEN
  561.                           BEGIN
  562.                              Script_String_2 := Script_String[1];
  563.                              Script_String   := COPY( Script_String,
  564.                                                         SUCC( IVal ),
  565.                                                         255 );
  566.                           END
  567.                        ELSE
  568.                           BEGIN
  569.                              GetDir( 0 , Script_String_2 );
  570.                              Script_String_2 := Script_String_2[1];
  571.                           END;
  572.                     END;
  573.  
  574.        DosSy      ,
  575.        EditFileSy ,
  576.        EraseFileSy,
  577.        KeySy      ,
  578.        MessageSy  ,
  579.        PrintFileSy,
  580.        RedialSy   ,
  581.        STextSy    ,
  582.        TextSy     ,
  583.        TranslateSy,
  584.        ViewFileSy,
  585.        WaitSy     ,
  586.        WriteLogSy : Copy_Script_String( Script_String , IBogus );
  587.  
  588.        DialSy     : BEGIN
  589.                        Copy_Script_String          ( Script_String , IBogus );
  590.                        Copy_Script_Integer_Constant( Script_Integer_1 );
  591.                     END;
  592.  
  593.        ExecuteSy  : BEGIN
  594.                        Copy_Script_String( Script_String_2 , IBogus );
  595.                        INC( Script_Buffer_Pos );
  596.                        Script_Parameter_Count := Script_Buffer^[Script_Buffer_Pos];
  597.                        IF( Script_Parameter_Count > 0 ) THEN
  598.                           BEGIN
  599.                              NEW( Script_Parameters );
  600.                              IF ( Script_Parameters <> NIL ) THEN
  601.                                 FOR I := 1 TO Script_Parameter_Count DO
  602.                                    BEGIN
  603.                                       INC( Script_Buffer_Pos );
  604.                                       Script_Parameters^[I] :=
  605.                                          Script_Buffer^[Script_Buffer_Pos];
  606.                                    END
  607.                              ELSE
  608.                                 BEGIN
  609.                                    Command := Null_Command;
  610.                                    INC( Script_Buffer_Pos , Script_Parameter_Count );
  611.                                    Script_Parameter_Count := 0;
  612.                                    EXIT;
  613.                                 END;
  614.                           END
  615.                        ELSE
  616.                           Script_Parameters := NIL;
  617.                        Script_String := 'E';
  618.                     END;
  619.  
  620.        ExeNewSy   : BEGIN
  621.                        Copy_Script_String( Script_String_2 , IBogus );
  622.                        Copy_Script_String( Script_String   , IBogus );
  623.                        Script_String := Script_String + CHR( CR );
  624.                        MOVE( Script_String[0], Mem[PrefixSeg:$80],
  625.                              SUCC( LENGTH( Script_String ) ) );
  626.                        Script_String := 'E';
  627.                     END;
  628.  
  629.        FileSy     : BEGIN
  630.                        Copy_Script_String ( Script_String    , IBogus );
  631.                        Copy_Script_String ( Script_String_2  , IBogus );
  632.                        Copy_Script_String ( Script_String_3  , IBogus );
  633.                     END;
  634.  
  635.        RInputSy   : BEGIN
  636.                        Copy_Script_String          ( Script_String , IBogus );
  637.                        Copy_Script_Integer_Constant( Script_Integer_1 );
  638.                        Copy_Script_String          ( Script_String_2 ,
  639.                                                      Script_Integer_2 );
  640.                     END;
  641.  
  642.        GoToXYSy   : BEGIN
  643.                        Copy_Script_Integer( Script_Integer_1 , IBogus );
  644.                        Copy_Script_Integer( Script_Integer_2 , IBogus );
  645.                     END;
  646.  
  647.        PImportSy  ,
  648.        ImportSy   ,
  649.        DeclareSy  : BEGIN
  650.                        Copy_Script_String          ( Script_String   , IBogus );
  651.                        Copy_Script_Integer_Constant( Script_Integer_1 );
  652.                        Copy_Script_Integer_Constant( Script_Integer_2 );
  653.                        Copy_Script_String          ( Script_String_2 , IBogus );
  654.                     END;
  655.  
  656.        IfOKSy     ,
  657.        IfOpSy     ,
  658.        IfConSy    ,
  659.        IfDialSy   ,
  660.        IfFoundSy  : BEGIN
  661.                        Copy_Script_Integer_Constant( Script_Integer_1 );
  662.                        Copy_Script_Integer_Constant( Script_Integer_2 );
  663.                        Copy_Script_Integer_Constant( Script_Integer_3 );
  664.                     END;
  665.  
  666.        IfRemStrSy ,
  667.        IfExistsSy ,
  668.        IfLocStrSy : BEGIN
  669.                        Copy_Script_Integer_Constant( Script_Integer_1 );
  670.                        Copy_Script_Integer_Constant( Script_Integer_2 );
  671.                        Copy_Script_Integer_Constant( Script_Integer_3 );
  672.                        Copy_Script_String ( Script_String , IBogus );
  673.                     END;
  674.  
  675.        KeySendSy  : BEGIN
  676.                        Copy_Script_String( Script_String , IBogus );
  677.                        Key_No := Get_Key_Index( Script_String );
  678.                     END;
  679.  
  680.  
  681.        ScriptSy   : BEGIN
  682.                        INC( Script_Buffer_Pos );
  683.                        Script_String     := CHR( Script_Buffer^[Script_Buffer_Pos] );
  684.                        Copy_Script_String( Script_String_2 , IBogus );
  685.                     END;
  686.  
  687.        SetSy      : BEGIN
  688.                        Copy_Script_Integer_Constant( Script_Integer_1 );
  689.                     END;
  690.  
  691.        CallSy     : BEGIN
  692.  
  693.                        INC( Script_Call_Depth );
  694.  
  695.                        WITH Script_Call_Stack[Script_Call_Depth] DO
  696.                           BEGIN
  697.                              Proc_Param  := Proc_Parameters;
  698.                              Proc_Got    := Proc_Parameter_Got;
  699.                              Proc_Count  := Proc_Parameter_Count;
  700.                              Save_Vars   := NIL;
  701.                           END;
  702.  
  703.                        Copy_Script_Integer_Constant( Script_Integer_1 );
  704.  
  705.                        INC( Script_Buffer_Pos );
  706.  
  707.                        Proc_Parameter_Count := Script_Buffer^[Script_Buffer_Pos];
  708.  
  709.                        IF( Proc_Parameter_Count > 0 ) THEN
  710.                           BEGIN
  711.                              NEW( Proc_Parameters );
  712.                              IF ( Proc_Parameters <> NIL ) THEN
  713.                                 FOR I := 1 TO Proc_Parameter_Count DO
  714.                                    BEGIN
  715.                                       INC( Script_Buffer_Pos );
  716.                                       Proc_Parameters^[I] :=
  717.                                          Script_Buffer^[Script_Buffer_Pos];
  718.                                    END
  719.                              ELSE
  720.                                 BEGIN
  721.                                    DEC( Script_Call_Depth );
  722.                                    Command := Null_Command;
  723.                                    EXIT;
  724.                                 END
  725.                           END
  726.                        ELSE
  727.                           Proc_Parameters := NIL;
  728.  
  729.                        Script_Call_Stack[Script_Call_Depth].Return_Addr :=
  730.                           Script_Buffer_Pos;
  731.  
  732.                        Proc_Parameter_Got    := 0;
  733.                        Proc_Parameter_Count  := 0;
  734.  
  735.                        Script_Buffer_Pos     := PRED( Script_Integer_1 );
  736.                        Command               := Null_Command;
  737.  
  738.                     END;
  739.  
  740.        GoToSy     : Copy_Script_Integer_Constant( Script_Integer_1 );
  741.  
  742.        WaitStrSy  : Get_WaitString;
  743.  
  744.        CaptureSy  ,
  745.        CopyFileSy ,
  746.        KeyDefSy   : BEGIN
  747.                        Copy_Script_String( Script_String   , IBogus );
  748.                        Copy_Script_String( Script_String_2 , IBogus );
  749.                     END;
  750.  
  751.        WhenSy     : BEGIN
  752.                        Copy_Script_String( Script_When_Text       , IBogus );
  753.                        Copy_Script_String( Script_When_Reply_Text , IBogus );
  754.                        When_Mode := ( LENGTH( Script_When_Text ) > 0 );
  755.                        Command   := Null_Command;
  756.                     END;
  757.  
  758.        FreeSpaceSy,
  759.        InputSy    : BEGIN
  760.                        Copy_Script_String( Script_String , IBogus );
  761.                        Copy_Script_String( Script_String_2 , Script_Integer_1 );
  762.                     END;
  763.  
  764.        ReceiveSy  ,
  765.        SendSy     : BEGIN
  766.                        Copy_Script_String( Script_String   , IBogus );
  767.                        Copy_Script_String( Script_String_2 , IBogus );
  768.                        Get_Transfer_Protocol;
  769.                     END;
  770.  
  771.        CloseSy    : Copy_Script_Integer( Script_Integer_1 , IBogus );
  772.  
  773.        OpenSy     : BEGIN
  774.                        Copy_Script_Integer( Script_Integer_1 , IBogus );
  775.                        Copy_Script_String ( Script_String    , IBogus );
  776.                        Copy_Script_Integer( Script_Integer_2 , IBogus );
  777.                     END;
  778.  
  779.        ReadSy     : BEGIN
  780.                        Copy_Script_Integer( Script_Integer_1 , IBogus );
  781.                        Copy_Script_String ( Script_String    , Script_Integer_2 );
  782.                        Copy_Script_Integer( Script_Integer_3 , IBogus );
  783.                     END;
  784.  
  785.        ReadLnSy   ,
  786.        WriteSy    ,
  787.        WriteLnSy  : BEGIN
  788.                       Copy_Script_Integer( Script_Integer_1 , IBogus );
  789.                       Copy_Script_String ( Script_String , Script_Integer_2 );
  790.                    END;
  791.  
  792.        WhereXYSy  : BEGIN
  793.                        Copy_Script_Integer( IBogus , Script_Integer_1 );
  794.                        Copy_Script_Integer( IBogus , Script_Integer_2 );
  795.                     END;
  796.  
  797.        WaitCountSy: BEGIN
  798.                        Copy_Script_Integer( LBogus , IBogus );
  799.                        Script_Wait_Check_Length := LBogus;
  800.                        Script_Wait_Char_Count   := 0;
  801.                        Script_Wait_Time         := Script_Default_Wait_Time;
  802.                        Fix_Wait_Time;
  803.                     END;
  804.  
  805.        WaitQuietSy: BEGIN
  806.                        Copy_Script_Integer( Script_Integer_1 , IBogus );
  807.                        IF ( Script_Integer_1 > 0 ) THEN
  808.                           BEGIN
  809.                              Script_WaitQuiet_Time := Script_Integer_1;
  810.                              Script_WaitQuiet_Time := Script_WaitQuiet_Time * 10;
  811.                              Script_Wait_Start     := TimeOfDayH;
  812.                              Really_Wait_String    := TRUE;
  813.                              WaitQuiet_Mode        := TRUE;
  814.                           END;
  815.                        Command := Null_Command;
  816.                     END;
  817.  
  818.        WaitTimeSy : BEGIN
  819.                        Copy_Script_Integer( Script_Integer_1 , IBogus );
  820.                        Script_Default_Wait_Time := Script_Integer_1;
  821.                        Command := Null_Command;
  822.                     END;
  823.  
  824.        WaitListSy : Get_WaitList;
  825.  
  826.        WhenDropSy : BEGIN
  827.                        Copy_Script_String( Script_When_Drop_Text , IBogus );
  828.                        When_Drop_Mode := ( LENGTH( Script_When_Drop_Text ) > 0 );
  829.                        Command        := Null_Command;
  830.                     END;
  831.  
  832.        ZapVarSy   : BEGIN
  833.                        Copy_Script_Integer( Script_Integer_1 , IBogus );
  834.                        Copy_Script_Integer( Script_Integer_2 , IBogus );
  835.                     END;
  836.  
  837.        MenuSy     : Get_Menu;
  838.  
  839.        GetVarSy   : BEGIN
  840.                        Copy_Script_String ( Script_String    , Script_Integer_1 );
  841.                        Copy_Script_String ( Script_String_2  , Script_Integer_2 );
  842.                        Copy_Script_String ( Script_String_3  , Script_Integer_3 );
  843.                        I := Locate_Var( Script_Variables,
  844.                                         Script_Variable_Count,
  845.                                         Script_String,
  846.                                         Script_Variables^[Script_Integer_2].Var_Value^,
  847.                                         Script_Variables^[Script_Integer_3].Var_Value^ );
  848.                        IF ( ( I = 0 ) AND ( Script_Stack_Depth > 0 ) ) THEN
  849.                           I := Locate_Var( Prev_Script_Variables,
  850.                                            Script_Stack_Position[Script_Stack_Depth].Vars_Count,
  851.                                            Script_String,
  852.                                            Script_Variables^[Script_Integer_2].Var_Value^,
  853.                                            Script_Variables^[Script_Integer_3].Var_Value^ );
  854.                        Command := Null_Command;
  855.                     END;
  856.  
  857.        SetVarSy   : BEGIN
  858.                        Copy_Script_String ( Script_String    , Script_Integer_1 );
  859.                        Copy_Script_String ( Script_String_4  , Script_Integer_4 );
  860.                        VPtrs := Script_Variables;
  861.                        I     := Locate_Var( Script_Variables,
  862.                                             Script_Variable_Count,
  863.                                             Script_String,
  864.                                             Script_String_2,
  865.                                             Script_String_3 );
  866.                        IF ( ( I = 0 ) AND ( Script_Stack_Depth > 0 ) ) THEN
  867.                           BEGIN
  868.                              VPtrs := Prev_Script_Variables;
  869.                              I     := Locate_Var( Prev_Script_Variables,
  870.                                                   Script_Stack_Position[Script_Stack_Depth].Vars_Count,
  871.                                                   Script_String,
  872.                                                   Script_String_2,
  873.                                                   Script_String_3 );
  874.                           END;
  875.                        IF ( I > 0 ) THEN
  876.                           BEGIN
  877.                              IF ( Script_String_2 = 'INTEGER' ) THEN
  878.                                 BEGIN
  879.                                    Script_String_4 := LTrim( Trim( Script_String_4 ) );
  880.                                    VAL( Script_String_4, IVal, L );
  881.                                    IF ( L = 0 ) THEN
  882.                                       BEGIN
  883.                                          Script_String_4[0] := CHR( 2 );
  884.                                          MOVE( IVal, Script_String_4[1],
  885.                                                SIZEOF( LONGINT ) );
  886.                                       END
  887.                                    ELSE
  888.                                       Script_String_4 := '' + '';
  889.                                 END;
  890.                              VPtrs^[I].Var_Value^ := Script_String_4;
  891.                           END;
  892.                        Command := Null_Command;
  893.                     END;
  894.  
  895.        GetDirSy:    BEGIN
  896.                        Copy_Script_String ( Script_String    , Script_Integer_1 );
  897.                        Copy_Script_String ( Script_String_2  , Script_Integer_2 );
  898.                     END;
  899.  
  900.        DirFirstSy ,
  901.        DirNextSy  : BEGIN
  902.                        IF ( Command = DirFirstSy ) THEN
  903.                           BEGIN
  904.                              Copy_Script_String ( Script_String    , IBogus );
  905.                              Copy_Script_String ( Script_String_2  , IBogus );
  906.                           END;
  907.                        Copy_Script_String ( Script_String_3  , Script_Integer_1 );
  908.                        Copy_Script_String ( Script_String_3  , Script_Integer_2 );
  909.                        Copy_Script_String ( Script_String_3  , Script_Integer_3 );
  910.                        Copy_Script_String ( Script_String_3  , Script_Integer_4 );
  911.                        Copy_Script_String ( Script_String_3  , Script_Integer_5 );
  912.                     END;
  913.  
  914.        CommFlushSy,
  915.        CommDrainSy: Copy_Script_Integer( Script_Integer_1 , IBogus );
  916.  
  917.    END (* CASE *);
  918.  
  919. END   (* Get_Script_Command *);
  920.