home *** CD-ROM | disk | FTP | other *** search
/ Power Programming / powerprogramming1994.iso / progtool / pibterm / pibt41s1.arc / EXECUTC2.MOD < prev    next >
Text File  |  1988-03-06  |  36KB  |  892 lines
  1. (*----------------------------------------------------------------------*)
  2.  
  3. BEGIN (* Execute_Command *)
  4.                                    (* Save current state of important params *)
  5.  
  6.    Alter_Status        := FALSE;
  7.    Save_Do_Status_Line := Do_Status_Line;
  8.  
  9.                                    (* Don't get confused by previous *)
  10.                                    (* script strings if manual entry *)
  11.  
  12.    IF ( NOT ( Use_Script OR Script_Learn_Mode ) ) THEN
  13.       BEGIN
  14.          Script_String       := '';
  15.          Script_String_2     := '';
  16.          Script_Integer_1    := 0;
  17.       END;
  18.                                    (* Execute chosen command *)
  19.  
  20.    CASE Command Of
  21.  
  22.        AddLFSy    :  BEGIN
  23.                         Toggle_Option( 'Add line feeds', Add_LF );
  24.                         Alter_Status := TRUE;
  25.                      END;
  26.  
  27.        AlarmSy    :  FOR I := 1 TO 5 DO
  28.                         BEGIN
  29.                            Menu_Beep;
  30.                            DELAY( 3 * Tenth_Of_A_Second_Delay );
  31.                         END;
  32.  
  33.        AreaCodeSy :  GetAreaCode;
  34.  
  35.        BreakSy    :  BEGIN
  36.                         Async_Send_Break;
  37.                         IF Script_Learn_Mode THEN
  38.                            BEGIN
  39.                               IF ( LENGTH( Script_String ) > 0 ) THEN
  40.                                  WRITELN( Script_File , 'SText "', Script_String, '"' );
  41.                               Script_String           := '';
  42.                               Script_Learn_Line_Count := 0;
  43.                               Script_Wait_Generated   := FALSE;
  44.                               WRITELN( Script_File , 'Break' );
  45.                            END;
  46.                      END;
  47.  
  48.        CaptureSy  :  BEGIN
  49.                         Get_Capture_File( Script_String , Script_String_2 );
  50.                         Alter_Status := TRUE;
  51.                      END;
  52.  
  53.        ChDirSy    :  BEGIN
  54.                         ChDir( Script_String_2[1] + ':' );
  55.                         Script_IO_Error := Int24Result;
  56.                         ChDir( Script_String );
  57.                         Script_IO_Error := Int24Result;
  58.                      END;
  59.  
  60.        ClearSy    :  Clear_Window;
  61.  
  62.        CloseSy    :  BEGIN
  63.  
  64.                         IF ( ( Script_Integer_1 < 1 ) OR
  65.                              ( Script_Integer_1 > MaxScriptOpenFiles ) ) THEN
  66.                            BEGIN
  67.                               Script_IO_Error := 999;
  68.                            END;
  69.  
  70.                         IF Script_File_Used[Script_Integer_1] THEN
  71.                            BEGIN
  72.                               IF Script_File_List[Script_Integer_1]^.Opened THEN
  73.                                  BEGIN
  74.                                        (*!I-*)
  75.                                     CLOSE( Script_File_List[Script_Integer_1]^.F );
  76.                                        (*!I+*)
  77.                                     Script_IO_Error := INT24Result;
  78.                                  END;
  79.                               DISPOSE( Script_File_List[Script_Integer_1] );
  80.                               Script_File_Used[Script_Integer_1] := FALSE;
  81.                            END;
  82.  
  83.  
  84.                      END;
  85.  
  86.        ClrEolSy   :  ClrEol;
  87.  
  88.        CommDrainSy:  Async_Drain_Output_Buffer( Script_Integer_1 );
  89.  
  90.        CommFlushSy:  BEGIN
  91.                                    (* 1 = flush input only  *)
  92.                                    (* 2 = flush output only *)
  93.                                    (* 3 = flush both        *)
  94.  
  95.                         IF ( Script_Integer_1 <> 1 ) THEN
  96.                            Async_Flush_Output_Buffer;
  97.  
  98.                         IF ( Script_Integer_1 <> 2 ) THEN
  99.                            Async_Purge_Buffer;
  100.  
  101.                      END;
  102.  
  103.        CopyFileSy :  CopyFile( Script_String , Script_String_2, Free_Size );
  104.  
  105.        PImportSy  ,
  106.        ImportSy   ,
  107.        DeclareSy  :  Allocate_Variable;
  108.  
  109.        DelaySy    :  DELAY( Delay_Time );
  110.  
  111.        DelLineSy  :  DelLine;
  112.  
  113.        DialSy     ,
  114.        ReDialSy   :  BEGIN
  115.                         T_Type := Terminal_To_Emulate;
  116.                         PibDialer( ( Command = ReDialSy ) , Script_String ,
  117.                                    ( Script_Integer_1 = 0 ) );
  118.                         Script_String    := '';
  119.                         Done             := ( Terminal_To_Emulate <> T_Type );
  120.                         IF Read_In_Script THEN
  121.                            BEGIN
  122.                               Read_In_Script   := FALSE;
  123.                               Process_Script( Script_File_Name , 'E');
  124.                            END;
  125.                         Alter_Status := TRUE;
  126.                      END;
  127.  
  128.        DirFirstSy :  BEGIN
  129.                         Search_Attr := 0;
  130.                         IF ( LENGTH( Script_String_2 ) > 0 ) THEN
  131.                            FOR I := 1 TO LENGTH( Script_String_2 ) DO
  132.                               CASE Script_String_2[I] OF
  133.                                  'R': Search_Attr := Search_Attr OR ReadOnly;
  134.                                  'H': Search_Attr := Search_Attr OR Hidden;
  135.                                  'S': Search_Attr := Search_Attr OR SysFile;
  136.                                  'V': Search_Attr := Search_Attr OR VolumeID;
  137.                                  'D': Search_Attr := Search_Attr OR Directory;
  138.                                  'A': Search_Attr := Search_Attr OR Archive;
  139.                                  ELSE;
  140.                               END (* CASE *)
  141.                         ELSE
  142.                            Search_Attr := AnyFile;
  143.                         FindFirst( Script_String, Search_Attr, Script_Search_Rec );
  144.                         Store_Find_Info;
  145.                      END;
  146.  
  147.        DirNextSy  :  BEGIN
  148.                         FindNext( Script_Search_Rec );
  149.                         Store_Find_Info;
  150.                      END;
  151.  
  152.        DosSy      :  BEGIN
  153.                         DosJump( Script_String );
  154.                         Script_String := '';
  155.                      END;
  156.  
  157.        EchoSy     :  BEGIN
  158.                         Toggle_Option( 'Local Echo', Local_Echo );
  159.                         Alter_Status := TRUE;
  160.                      END;
  161.  
  162.        EditSy     :  Edit_A_Line;
  163.  
  164.        EditFileSy :  Do_File_Editing;
  165.  
  166.        EraseFileSy:  BEGIN
  167.                         ASSIGN( F , Script_String );
  168.                         ERASE ( F );
  169.                         Script_IO_Error := Int24Result;
  170.                      END;
  171.  
  172.        ExitSy     :  IF Script_File_Mode THEN
  173.                         BEGIN
  174.  
  175.                            Alter_Status := TRUE;
  176.                            Com_Line_Scr := ( Scripts[Current_Script_Num].Script_Name[1] = '!' );
  177.  
  178.                            IF ( Script_Stack_Depth <= 0 ) THEN
  179.                               BEGIN
  180.                                  IF ( Auto_Unload_Scripts OR Com_Line_Scr ) THEN
  181.                                     Unload_This_Script;
  182.                                  IF ( NOT Com_Line_Scr ) THEN
  183.                                     Toggle_Option( 'Script Mode', Script_File_Mode );
  184.                                  Clear_Script_Variables;
  185.                                  Script_File_Mode        := FALSE;
  186.                                  Script_Command_Key_Mode := FALSE;
  187.                               END
  188.                            ELSE
  189.                               BEGIN
  190.  
  191.                                  IF ( Auto_Unload_Scripts OR Com_Line_Scr ) THEN
  192.                                     Unload_This_Script;
  193.  
  194.                                    (* Free space for variable values *)
  195.  
  196.                                  Zap_Script_Variables( 0 ,
  197.                                                        Script_Variable_Count );
  198.  
  199.                                    (* Free space for variable pointers *)
  200.  
  201.                                  MyFreeMem( Script_Variables ,
  202.                                           ( Script_Variable_Count + 3 ) * SizeOf( Script_Variables^[1] ) );
  203.  
  204.                                    (* Free space for any parameters *)
  205.  
  206.                                  IF ( Script_Parameter_Count > 0 ) THEN
  207.                                     IF ( Script_Parameters <> NIL ) THEN
  208.                                        BEGIN
  209.                                           DISPOSE( Script_Parameters );
  210.                                           Script_Parameters := NIL;
  211.                                        END;
  212.  
  213.                                  WITH Script_Stack_Position[Script_Stack_Depth] DO
  214.                                     BEGIN
  215.                                        Script_Buffer           := Buffer_Ptr;
  216.                                        Script_Buffer_Pos       := Buffer_Pos;
  217.                                        Current_Script_Num      := Script_Num;
  218.                                        Script_Variables        := Vars_Ptr;
  219.                                        Script_Variable_Count   := Vars_Count;
  220.                                        Script_Parameters       := Params_Ptr;
  221.                                        Script_Parameter_Count  := Params_Count;
  222.                                        Script_Parameter_Got    := Params_Got;
  223.                                        Prev_Script_Variables   := Prev_Ptr;
  224.                                     END;
  225.                                  DEC( Script_Stack_Depth );
  226.  
  227.                               END;
  228.  
  229.                         END;
  230.  
  231.        ExitAllSy  :  BEGIN
  232.                         Exit_All_Scripts;
  233.                         Alter_Status := TRUE;
  234.                      END;
  235.  
  236.        FastCSy    :  Fast_Change_Params;
  237.  
  238.        FileSy     :  REPEAT
  239.  
  240.                         PibFileManipulation( File_Done  ,
  241.                                              Do_Editing ,
  242.                                              Do_Viewing );
  243.                         IF Do_Editing THEN
  244.                            Do_File_Editing
  245.                         ELSE IF Do_Viewing THEN
  246.                            Do_File_Viewing;
  247.  
  248.                      UNTIL( File_Done );
  249.  
  250.        FreeSpaceSy:  BEGIN
  251.                         IF ( LENGTH( Script_String ) = 0 ) THEN
  252.                            Drive_Word := 0
  253.                         ELSE
  254.                            Drive_Word := SUCC( ORD( Script_String[1] ) - ORD('A') );
  255.                         Free_Size := DiskFree( Drive_Word );
  256.                         STR( Free_Size , Script_Variables^[Script_Integer_1].Var_Value^ );
  257.                      END;
  258.  
  259.        GetDirSy   :  BEGIN
  260.                         GetDir( 0 , Script_String );
  261.                         Script_IO_Error := Int24Result;
  262.                         Script_Variables^[Script_Integer_1].Var_Value^ := Script_String[1];
  263.                         IF ( Script_IO_Error <> 0 ) THEN
  264.                            Script_String_2 := ''
  265.                         ELSE
  266.                            Script_String_2 := COPY( Script_String, 3, 
  267.                                                     LENGTH( Script_String ) - 2 );
  268.                         Script_Variables^[Script_Integer_2].Var_Value^ := Script_String_2;
  269.                      END;
  270.  
  271.  
  272.        GossipSy   :  BEGIN
  273.                         Toggle_Option( 'Gossip mode', Gossip_Mode_On );
  274.                         Done := TRUE;
  275.                         IF Gossip_Mode_On THEN
  276.                            BEGIN
  277.                               Saved_Gossip_Term   := Terminal_To_Emulate;
  278.                               Terminal_To_Emulate := Gossip;
  279.                            END
  280.                         ELSE
  281.                            BEGIN
  282.                               Terminal_To_Emulate := Saved_Gossip_Term;
  283.                            END;
  284.                      END;
  285.  
  286.        GoToSy     :  Script_Buffer_Pos := PRED( Script_Integer_1 );
  287.  
  288.        GoToXYSy   :  GoToXY( Script_Integer_1, Script_Integer_2 );
  289.  
  290.        HangUpSy   :  BEGIN (* Hang-up Phone *)
  291.  
  292.                         Draw_Titled_Box( Saved_Screen, 10, 10, 60, 15, '' );
  293.  
  294.                         WRITELN;
  295.                         WRITELN('*** Hanging up the phone ***');
  296.  
  297.                                    (* Hang up the phone *)
  298.  
  299.                         HangUpPhone;
  300.  
  301.                         IF Async_Carrier_Detect THEN
  302.                            WRITELN('*** Phone not hung up, try again ***')
  303.                         ELSE
  304.                            BEGIN
  305.                               WRITELN('*** Phone hung up ***');
  306.                               Write_Log('Phone hung up', FALSE , FALSE );
  307.                            END;
  308.  
  309.                         Window_Delay;
  310.  
  311.                         Restore_Screen_And_Colors( Saved_Screen );
  312.  
  313.                      END   (* Hang-up Phone *);
  314.  
  315.        HostSy     :  BEGIN (* Set host mode *)
  316.                         Done                := TRUE;
  317.                         Saved_Gossip_Term   := Terminal_To_Emulate;
  318.                         Terminal_To_Emulate := HostMode;
  319.                      END   (* Set host mode *);
  320.  
  321.  
  322.        IfConSy    :  Do_Simple_If( Async_Carrier_Detect );
  323.  
  324.        IfDialSy   :  Do_Simple_If( Script_Dialed );
  325.  
  326.  
  327.        IfExistsSy :  BEGIN
  328.                              (*!I-*)
  329.                         ASSIGN( F , Script_String );
  330.                         RESET ( F );
  331.                              (*!I+*)
  332.                         I := Int24Result;
  333.                              (*!I-*)
  334.                         CLOSE ( F );
  335.                              (*!I+*)
  336.                         J := Int24Result;
  337.  
  338.                         Do_Simple_If( ( I = 0 ) );
  339.  
  340.                      END;
  341.  
  342.        IfFoundSy  :  Do_Simple_If( Script_Wait_Found );
  343.  
  344.        IfLocStrSy :  BEGIN
  345.  
  346.                         IF ( LENGTH( Script_Reply  ) > 0 ) AND
  347.                            ( LENGTH( Script_String ) > 0 ) THEN
  348.                            Script_Reply_Found :=
  349.                               ( POS( Script_Reply , Script_String ) > 0 );
  350.  
  351.                         Do_Simple_If( Script_Reply_Found );
  352.  
  353.                      END;
  354.  
  355.        IfOKSy     :  Do_Simple_If( Script_IO_Error <> 0 );
  356.  
  357.        IfOpSy     :  BEGIN
  358.                         Execute_Stack( 0 );
  359.                         I := ( ORD( Script_Variables^[0].Var_Value^[2] ) SHL 8 ) OR
  360.                                ORD( Script_Variables^[0].Var_Value^[1] );
  361. {
  362.                         IF Debug_Mode THEN
  363.                            Debug_Write('---> IF returns ' + ITOS( I ) );
  364. }
  365.                         IF ( ( I AND 1 ) = 1 ) THEN
  366.                            Script_Buffer_Pos := PRED( Script_Integer_2 )
  367.                         ELSE
  368.                            Script_Buffer_Pos := PRED( Script_Integer_3 );
  369.                      END;
  370.  
  371.        IfRemStrSy :  BEGIN
  372.  
  373.                         IF ( LENGTH( Script_Remote_Reply ) > 0 ) AND
  374.                            ( LENGTH( Script_String       ) > 0 ) THEN
  375.                            Script_Remote_Reply_OK :=
  376.                               ( POS( Script_Remote_Reply , Script_String ) > 0 );
  377.  
  378.                         Do_Simple_If( Script_Remote_Reply_OK );
  379.  
  380.                      END;
  381.  
  382.        InfoSy     :  Display_Help( FALSE );
  383.  
  384.        InputSy    :  BEGIN
  385.                         WRITE( Script_String );
  386.                         Script_Reply := '';
  387.                         Read_Edited_String( Script_Reply );
  388.                         Script_Reply_Found := FALSE;
  389.                         IF ( Script_Integer_1 > 2 ) THEN
  390.                            BEGIN
  391.                               Script_Variables^[Script_Integer_1].Var_Value^ :=
  392.                                  Script_Reply;
  393. {
  394.                               IF Debug_Mode THEN
  395.                                  Debug_Write('   --> Variable read into is #' +
  396.                                        ITOS( Script_Integer_1 ) + ' = ' +
  397.                                        Script_Variables^[Script_Integer_1].Var_Name );
  398. }
  399.                            END;
  400.                      END;
  401.  
  402.        InsLineSy  :  InsLine;
  403.  
  404.        KeyDefSy   :  Define_Key( Script_String , Script_String_2 );
  405.  
  406.        KeyFlushSy :  WHILE ( PibTerm_KeyPressed ) DO
  407.                         Read_Kbd( Ch );
  408.  
  409.        KeySendSy  :  IF ( Key_No <> Command_Key ) THEN
  410.                         Handle_Function_Key( CHR( Key_No ) )
  411.                      ELSE
  412.                         Process_Script( '' , 'K' );
  413.  
  414.        KeySy      :  Set_Input_Keys( Script_String , TRUE );
  415.  
  416.        LogSy      :  BEGIN
  417.                         Toggle_Option('List session on printer', Printer_On );
  418.                         Alter_Status := TRUE;
  419.                      END;
  420.  
  421.        MessageSy  :  BEGIN
  422.                         Script_String := Read_Ctrls( Script_String ) +
  423.                                          CHR( CR ) + CHR( LF );
  424.                         FOR I := 1 TO LENGTH( Script_String ) DO
  425.                            IF Use_Dos_Con_Output THEN
  426.                               Display_Character_Through_DOS( Script_String[I] )
  427.                            ELSE
  428.                               Display_Character( Script_String[I] );
  429.                      END;
  430.  
  431.        MenuSy     :  BEGIN
  432.                                    (* Display menu *)
  433.  
  434.                         Menu_Display_Choices( Script_Menu_Holder^ );
  435.  
  436.                                    (* Get choice *)
  437.  
  438.                         I     := Menu_Get_Choice( Script_Menu_Holder^ , Erase_Menu );
  439.                         LongI := I;
  440.  
  441.                         MOVE( LongI , Script_Variables^[Script_Integer_1].Var_Value^[1],
  442.                               SIZEOF( LongI ) );
  443.  
  444.                         DISPOSE( Script_Menu_Holder );
  445.  
  446.                      END;
  447.  
  448.        MuteSy     :  BEGIN
  449.                         Toggle_Option('Silent Mode', Silent_Mode );
  450.                         Menu_Set_Beep( NOT Silent_Mode );
  451.                      END;
  452.  
  453.        OpenSy     :  BEGIN
  454.  
  455.                         IF ( ( Script_Integer_1 < 1 ) OR
  456.                              ( Script_Integer_1 > MaxScriptOpenFiles ) ) THEN
  457.                               Script_IO_Error := 999
  458.                         ELSE
  459.                            BEGIN
  460.  
  461.                               IF Script_File_Used[Script_Integer_1] THEN
  462.                                  BEGIN
  463.                                        (*!I-*)
  464.                                     CLOSE( Script_File_List[Script_Integer_1]^.F );
  465.                                        (*!I+*)
  466.                                     DISPOSE( Script_File_List[Script_Integer_1] );
  467.                                  END;
  468.  
  469.                               NEW( Script_File_List[Script_Integer_1] );
  470.  
  471.                               IF ( Script_File_List[Script_Integer_1] = NIL ) THEN
  472.                                  Script_IO_Error := 999
  473.                               ELSE
  474.                                  BEGIN
  475.  
  476.                                     Script_File_Used[Script_Integer_1] := TRUE;
  477.  
  478.                                     WITH Script_File_List[Script_Integer_1]^ DO
  479.                                        BEGIN
  480.  
  481.                                           ReadOnly  := ( Script_Integer_2 = 0 );
  482.                                           EOF_Seen  := FALSE;
  483.  
  484.                                              (*!I-*)
  485.                                           ASSIGN( F , Script_String );
  486.  
  487.                                           CASE Script_Integer_2 OF
  488.                                              0: BEGIN
  489.                                                    ASSIGN( F , Script_String );
  490.                                                    RESET  ( F );
  491.                                                    Script_IO_Error := INT24Result;
  492.                                                 END;
  493.                                              1: BEGIN
  494.                                                    ASSIGN( F , Script_String );
  495.                                                    REWRITE( F );
  496.                                                    Script_IO_Error := INT24Result;
  497.                                                 END;
  498.                                              2: Flag := Open_For_Append( F,
  499.                                                                          Script_String,
  500.                                                                          Script_IO_Error );
  501.                                           END (* CASE *);
  502.  
  503.                                              (*!I+*)
  504.  
  505.                                           Opened := ( Script_IO_Error = 0 );
  506.  
  507.                                        END;
  508.  
  509.                                  END;
  510.  
  511.                            END;
  512.  
  513.                      END;
  514.  
  515.        GetParamSy ,
  516.        SetParamSy ,
  517.        ParamSy    :  BEGIN
  518.                         T_Type        := Terminal_To_Emulate;
  519.                         Flag          := Set_Params( FALSE , Use_Script );
  520.                         Done          := ( Terminal_To_Emulate <> T_Type );
  521.                         Alter_Status  := TRUE;
  522.                      END;
  523.  
  524.        PrintFileSy:  Print_A_File( Script_String );
  525.  
  526.        QuitSy     :  BEGIN (* Quit *)
  527.  
  528.                         Draw_Titled_Box( Saved_Screen, 10, 10, 55, 13, '' );
  529.  
  530.                         IF Script_File_Mode THEN
  531.                            BEGIN
  532.                               IF Script_Integer_1 = 0 THEN
  533.                                  Script_File_Mode :=
  534.                                     NOT YesNo('Stop running current script (Y/N) ? ')
  535.                               ELSE
  536.                                  BEGIN
  537.                                     Script_File_Mode    := FALSE;
  538.                                     Script_File_Name    := '';
  539.                                     Done                := TRUE;
  540.                                  END;
  541.                               IF ( NOT Script_File_Mode ) THEN
  542.                                  Clear_Script_Variables;
  543.                               Alter_Status := TRUE;
  544.                            END
  545.                         ELSE IF ( When_Mode OR When_Drop_Mode ) THEN
  546.                            BEGIN
  547.                               When_Mode :=
  548.                                  NOT YesNo('Stop WHEN and WHENDROP processing (Y/N) ? ');
  549.                               When_Drop_Mode := When_Mode;
  550.                               IF ( NOT When_Mode ) THEN
  551.                                  BEGIN
  552.                                     Script_When_Text       := '';
  553.                                     Script_When_Reply_Text := '';
  554.                                     Script_When_Drop_Text  := '';
  555.                                  END;
  556.                            END
  557.                         ELSE
  558.                            Done := YesNo('Are you sure you want to quit (Y/N) ? ');
  559.  
  560.                         Restore_Screen_And_Colors( Saved_Screen );
  561.  
  562.                         PibTerm_Done := Done;
  563.  
  564.                      END;
  565.  
  566.        QuitAllSy  :  BEGIN (* Stop PibTerm execution from script *)
  567.                         Done         := TRUE;
  568.                         PibTerm_Done := TRUE;
  569.                      END;
  570.  
  571.        ReadLnSy   :  IF ( Script_Integer_1 = 0 ) THEN
  572.                         BEGIN
  573.                            READLN( Script_Variables^[Script_Integer_2].Var_Value^ );
  574.                            Script_IO_Error := INT24Result;
  575.                         END
  576.                      ELSE IF Script_File_Used[Script_Integer_1] THEN
  577.                         WITH Script_File_List[Script_Integer_1]^ DO
  578.                            BEGIN
  579.                               IF ( Opened AND ReadOnly AND ( NOT EOF_Seen ) ) THEN
  580.                                  BEGIN
  581.                                        (*!I-*)
  582.                                     READLN( F ,
  583.                                           Script_Variables^[Script_Integer_2].Var_Value^ );
  584.                                        (*!I+*)
  585.                                     Script_IO_Error := INT24Result;
  586.                                     IF ( NOT EOF_Seen ) THEN
  587.                                        EOF_Seen := EOF( F );
  588.                                  END
  589.                               ELSE
  590.                                  Script_IO_Error := 999;
  591.                            END;
  592.  
  593.        ReadSy     :  BEGIN
  594. {
  595.                     Write_Log('U='+CHR( ORD('0') + Script_Integer_1 ), FALSE,
  596.                               FALSE);
  597.                     Write_Log('N='+CHR( ORD('0') + Script_Integer_3 ), FALSE,
  598.                               FALSE);
  599. }
  600.                      IF Script_File_Used[Script_Integer_1] THEN
  601.                         WITH Script_File_List[Script_Integer_1]^ DO
  602.                            BEGIN
  603.                               Flag := ( Script_Integer_1 = 0 );
  604.                               IF ( Opened AND ( Flag OR ReadOnly ) ) THEN
  605.                                  Read_Chars( F,
  606.                                              Script_Variables^[Script_Integer_2].Var_Value^,
  607.                                              Script_Integer_3,
  608.                                              EOF_Seen,
  609.                                              Flag )
  610.                               ELSE
  611.                                  Script_IO_Error := 999;
  612.                            END;
  613.                      END;
  614.  
  615.        ReceiveSy  :  BEGIN
  616.  
  617.                         IF LENGTH( Script_String ) > 0 THEN
  618.                            FileName        := Script_String;
  619.  
  620.                         IF ( Script_Integer_1 > 0 ) THEN
  621.                            BEGIN
  622.                               Trans_Type      := Transfers[ Script_Integer_1 ];
  623.                               Script_Transfer := TRUE;
  624.                            END
  625.                         ELSE
  626.                            Trans_Type := None;
  627.  
  628.                         PibDownLoad( Trans_Type );
  629.  
  630.                         Script_Transfer := FALSE;
  631.  
  632.  
  633.                      END;
  634.  
  635.        ResetSy    :  Script_Buffer_Pos := 0;
  636.  
  637.        ReturnSy   :  IF ( Script_Call_Depth > 0 ) THEN
  638.                         WITH Script_Call_Stack[Script_Call_Depth] DO
  639.                            BEGIN
  640.                               IF ( Proc_Parameter_Count > 0 ) THEN
  641.                                  DISPOSE( Proc_Parameters );
  642.                               Script_Buffer_Pos    := Return_Addr;
  643.                               Proc_Parameters      := Proc_Param;
  644.                               Proc_Parameter_Got   := Proc_Got;
  645.                               Proc_Parameter_Count := Proc_Count;
  646.                               DEC( Script_Call_Depth );
  647. {
  648.                            IF Debug_Mode THEN
  649.                               Debug_Write('---> Ret from proc to location ' +
  650.                                           ITOS( Script_Buffer_Pos ) );
  651. }
  652.                            END;
  653.  
  654.        RInputSy   :  Remote_Input;
  655.  
  656.        ExecuteSy  ,
  657.        ExeNewSy   ,
  658.        ScriptSy   :  BEGIN
  659.                         IF ( LENGTH( Script_String ) > 0 ) THEN
  660.                            Ch := Script_String[1]
  661.                         ELSE
  662.                            Ch := ' ';
  663.                         Process_Script( Script_String_2 , Ch );
  664.                         Alter_Status := TRUE;
  665.                      END;
  666.  
  667.        SDumpSy    :  Do_Screen_Dump;
  668.  
  669.        SendSy     :  BEGIN
  670.  
  671.                         IF LENGTH( Script_String ) > 0 THEN
  672.                            FileName        := Script_String;
  673.  
  674.                         IF ( Script_Integer_1 > 0 ) THEN
  675.                            BEGIN
  676.                               Trans_Type      := Transfers[ Script_Integer_1 ];
  677.                               Script_Transfer := TRUE;
  678.                            END
  679.                         ELSE
  680.                            Trans_Type := None;
  681.  
  682.                         PibUpLoad( Trans_Type );
  683.  
  684.                         Script_Transfer := FALSE;
  685.  
  686.  
  687.                      END;
  688.  
  689.        SetSy      :  BEGIN
  690. {
  691.                         IF Debug_Mode THEN
  692.                            Debug_Write('---> Setting variable # ' +
  693.                                    ITOS( Script_Integer_1 ) + ', is ' +
  694.                                    Script_Variables^[Script_Integer_1].Var_Name );
  695. }
  696.                         Execute_Stack( Script_Integer_1 );
  697.  
  698.                      END;
  699.  
  700.  
  701.        STextSy    :  BEGIN
  702.                         Send_Function_Key( Read_Ctrls( Script_String ) );
  703.                         Script_String := '';
  704.                      END;
  705.  
  706.        TextSy     :  BEGIN
  707.                         Async_Send_String( Script_String );
  708.                         Script_String := '';
  709.                      END;
  710.  
  711.        TimersSy   :  Display_Timers;
  712.  
  713.        TranslateSy:  Set_Translate_Table( Script_String );
  714.  
  715.        ViewSy     :  IF Review_On THEN
  716.  
  717.                         IF ( Review_Head > 0 ) THEN
  718.                            Review_Captured_Text
  719.                         ELSE
  720.                            BEGIN
  721.  
  722.                               Draw_Titled_Box( Saved_Screen, 10, 10, 60, 14, '' );
  723.  
  724.                               WRITE('Review buffer empty.');
  725.  
  726.                               Window_Delay;
  727.  
  728.                               Restore_Screen_And_Colors( Saved_Screen );
  729.  
  730.                            END
  731.                         ELSE
  732.                      BEGIN
  733.  
  734.                         Draw_Titled_Box( Saved_Screen, 10, 10, 60, 14, '' );
  735.  
  736.                         WRITE('Review buffer not active.');
  737.  
  738.                         Window_Delay;
  739.  
  740.                         Restore_Screen_And_Colors( Saved_Screen );
  741.  
  742.                      END;
  743.  
  744.        ViewFileSy : Do_File_Viewing;
  745.  
  746.        WaitSy     : BEGIN
  747.  
  748.                        TimeW := COPY( Script_String, 1, 8 );
  749.  
  750.                        Draw_Titled_Box( Local_Save, 10, 10, 60, 14,
  751.                                         'Wait For Specified Time' );
  752.  
  753.                        WRITELN('Waiting for:  ',TimeW);
  754.                        WRITE  ('Current time: ');
  755.  
  756.                        I         := WhereY;
  757.                        TimeN     := '';
  758.                        ESC_Found := FALSE;
  759.  
  760.                        REPEAT
  761.                           TimeO := TimeN;
  762.                           TimeN := TimeString( TimeOfDay , Military_Time );
  763.                           IF ( TimeN <> TimeO ) THEN
  764.                              BEGIN
  765.                                 GoToXY( 15 , I );
  766.                                 WRITE( TimeN );
  767.                              END;
  768.                           IF PibTerm_KeyPressed THEN
  769.                              BEGIN
  770.                                 Read_Kbd( Ch );
  771.                                 IF ORD( Ch ) = ESC THEN
  772.                                    BEGIN
  773.                                       ESC_Found := TRUE;
  774.                                       IF PibTerm_KeyPressed THEN
  775.                                          Read_Kbd( Ch );
  776.                                    END;
  777.                              END;
  778.                        UNTIL( TimeN = TimeW ) OR ESC_Found;
  779.  
  780.                        Restore_Screen_And_Colors( Local_Save );
  781.  
  782.                     END;
  783.  
  784.        WhereXYSy  : BEGIN
  785.                        LongI := WhereX;
  786.                        LongJ := WhereY;
  787.                        MOVE( LongI ,
  788.                              Script_Variables^[Script_Integer_1].Var_Value^[1],
  789.                              SIZEOF( LongI ) );
  790.                        MOVE( LongJ ,
  791.                              Script_Variables^[Script_Integer_2].Var_Value^[1],
  792.                              SIZEOF( LongJ ) );
  793.                     END;
  794.  
  795.        WriteLnSy  : IF ( Script_Integer_1 = 0 ) THEN
  796.                        WRITELN( Script_String )
  797.                     ELSE IF Script_File_Used[Script_Integer_1] THEN
  798.                        WITH Script_File_List[Script_Integer_1]^ DO
  799.                           BEGIN
  800.                              IF ( Opened AND ( NOT ReadOnly ) ) THEN
  801.                                 BEGIN
  802.                                       (*!I-*)
  803.                                    WRITELN( F , Script_String );
  804.                                       (*!I+*)
  805.                                    Script_IO_Error := INT24Result;
  806.                                 END
  807.                              ELSE
  808.                                 Script_IO_Error := 999;
  809.                           END;
  810.  
  811.        WriteSy    : IF ( Script_Integer_1 = 0 ) THEN
  812.                        WRITE( Script_String )
  813.                     ELSE IF Script_File_Used[Script_Integer_1] THEN
  814.                        WITH Script_File_List[Script_Integer_1]^ DO
  815.                           BEGIN
  816.                              IF ( Opened AND ( NOT ReadOnly ) ) THEN
  817.                                 BEGIN
  818.                                       (*!I-*)
  819.                                    WRITE( F , Script_String );
  820.                                       (*!I+*)
  821.                                    Script_IO_Error := INT24Result;
  822.                                 END
  823.                              ELSE
  824.                                 Script_IO_Error := 999;
  825.                           END;
  826.  
  827.        WriteLogSy : Write_Log( Script_String , FALSE , FALSE );
  828.  
  829.        ZapVarSy   : Zap_Script_Variables( Script_Integer_1 , Script_Integer_2 );
  830.  
  831.       ELSE        ;
  832.  
  833.    END (* CASE *);
  834.                                    (* Update status display if parameters  *)
  835.                                    (* changed.                             *)
  836.  
  837.    Do_Script_Tests := Waitstring_Mode OR When_Mode OR
  838.                       WaitCount_Mode  OR WaitQuiet_Mode OR
  839.                       Script_Learn_Mode;
  840.  
  841.    IF Reverse_Status_Colors THEN
  842.       Status_Line_Attr := ( ForeGround_Color AND 7 ) SHL 4 + BackGround_Color
  843.    ELSE
  844.       Status_Line_Attr := ( Status_BackGround_Color AND 7 ) SHL 4 + Status_ForeGround_Color;
  845.  
  846.    Ansi_Term          := ( Terminal_To_Emulate = Ansi  ) OR
  847.                          ( Terminal_To_Emulate = VT100 );
  848.  
  849.    Do_Status_Line     := Show_Status_Line AND
  850.                          ( NOT Graphics_Terminal_Mode );
  851.  
  852.    IF ( NOT Ansi_Term ) THEN
  853.       Do_Status_Line := Do_Status_Line AND ( NOT Use_Dos_Con_Output );
  854.  
  855.    Do_Status_Time     := Do_Status_Line AND Show_Status_Time;
  856.  
  857.                                    (* If any status stuff changed, *)
  858.                                    (* rewrite the status line      *)
  859.    IF Do_Status_Line THEN
  860.       IF ( Alter_Status OR Reset_Comm_Port ) THEN
  861.          BEGIN
  862.             IF ( WhereY = Max_Screen_Line ) THEN
  863.                BEGIN
  864.                   MoveToXY( WhereX , PRED( Max_Screen_Line ) );
  865.                   Do_Status_Line := FALSE;
  866.                   Scroll( 1, Max_Screen_Line, 1, Max_Screen_Col, 1,
  867.                           ForeGround_Color, BackGround_Color );
  868.                   Do_Status_Line := TRUE;
  869.                END;
  870.             Set_Status_Line_Name( Short_Terminal_Name );
  871.             Write_To_Status_Line( Status_Line_Name, 1 );
  872.          END
  873.       ELSE (* Leave status line as is *)
  874.    ELSE
  875.       IF( Save_Do_Status_Line ) THEN
  876.          BEGIN (* Remove status line that was there before *)
  877.  
  878.             Status_Line_Attr   := ( BackGround_Color AND 7 ) SHL 4 +
  879.                                   ForeGround_Color;
  880.  
  881.             Do_Status_Line := TRUE;
  882.  
  883.             Write_To_Status_Line( DUPL( ' ' , Max_Screen_Col ), 1 );
  884.  
  885.             Do_Status_Line := FALSE;
  886.  
  887.          END;
  888.  
  889.    Reset_Comm_Port := FALSE;
  890.  
  891. END   (* Execute_Command *);
  892.