home *** CD-ROM | disk | FTP | other *** search
/ Programmer Power Tools / Programmer Power Tools.iso / pibterm / pibt41s2.arc / PIBDIALA.MOD < prev    next >
Encoding:
Text File  |  1988-02-07  |  48.1 KB  |  1,298 lines
  1. (*----------------------------------------------------------------------*)
  2. (*                PibDialer --- Dialing Management                      *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. PROCEDURE PibDialer( ReDial         : BOOLEAN;
  6.                      Dialing_String : AnyStr;
  7.                      Allow_Script   : BOOLEAN );
  8.  
  9. (*----------------------------------------------------------------------*)
  10. (*                                                                      *)
  11. (*     Procedure:  PibDialer                                            *)
  12. (*                                                                      *)
  13. (*     Purpose:    Main routine for dials/redials                       *)
  14. (*                                                                      *)
  15. (*     Calling Sequence:                                                *)
  16. (*                                                                      *)
  17. (*        PibDialer( ReDial         : BOOLEAN;                          *)
  18. (*                   Dialing_String : AnyStr );                         *)
  19. (*                                                                      *)
  20. (*           ReDial --- TRUE for redial, FALSE for ordinary dial        *)
  21. (*           Dialing_String --- if not null, use this as number to      *)
  22. (*                              be dialed.                              *)
  23. (*                                                                      *)
  24. (*     Calls:                                                           *)
  25. (*                                                                      *)
  26. (*           Dial_A_Number                                              *)
  27. (*           Redial_A_Number                                            *)
  28. (*                                                                      *)
  29. (*----------------------------------------------------------------------*)
  30.  
  31. CONST
  32.    Empty_Name   = '-------------------------';
  33.    Empty_Number = ' # ### ###-####';
  34.  
  35. VAR
  36.    Local_Save_4       : Saved_Screen_Ptr;
  37.    Session_Active     : BOOLEAN;
  38.    Xpos1              : INTEGER;
  39.    Manual_Dial        : BOOLEAN;
  40.    Quit               : BOOLEAN;
  41.    Use_Short_Prompt   : BOOLEAN;
  42.    Entry_String       : STRING[30];
  43.    First_Display_Time : BOOLEAN;
  44.    Dial_Search_String : AnyStr;
  45.    Saved_Insert_Mode  : BOOLEAN;
  46.    Connection_Made    : BOOLEAN;
  47.    Redial_Count       : INTEGER;
  48.    SVal               : STRING[10];
  49.    Ch                 : CHAR;
  50.  
  51. (*----------------------------------------------------------------------*)
  52. (*          Dialer_Carrier_Detect --- Look for carrier detect           *)
  53. (*----------------------------------------------------------------------*)
  54.  
  55. FUNCTION Dialer_Carrier_Detect : BOOLEAN;
  56.  
  57. (*----------------------------------------------------------------------*)
  58. (*                                                                      *)
  59. (*     Function:  Dialer_Carrier_Detect                                 *)
  60. (*                                                                      *)
  61. (*     Purpose:   Looks for a carrier detect                            *)
  62. (*                                                                      *)
  63. (*     Calling Sequence:                                                *)
  64. (*                                                                      *)
  65. (*        Carrier := Dialer_Carrier_Detect;                             *)
  66. (*                                                                      *)
  67. (*           Carrier  --- TRUE if carrier detect found                  *)
  68. (*                                                                      *)
  69. (*     Calls:                                                           *)
  70. (*                                                                      *)
  71. (*        Async_Carrier_Detect;                                         *)
  72. (*                                                                      *)
  73. (*     Remarks:                                                         *)
  74. (*                                                                      *)
  75. (*        This routine is essentially a filter for Async_Carrier_Detect *)
  76. (*        except that if the global flag Modem_Carrier_High is set, it  *)
  77. (*        returns FALSE.  This is to support modems which always keep   *)
  78. (*        the carrier detect line high.                                 *)
  79. (*                                                                      *)
  80. (*----------------------------------------------------------------------*)
  81.  
  82. BEGIN (* Dialer_Carrier_Detect *)
  83.  
  84.    IF Modem_Carrier_High THEN
  85.       Dialer_Carrier_Detect := FALSE
  86.    ELSE
  87.       Dialer_Carrier_Detect := Async_Carrier_Detect;
  88.  
  89. END   (* Dialer_Carrier_Detect *);
  90.  
  91. (*----------------------------------------------------------------------*)
  92. (*          Read_Number_Or_ESC --- Read in number or get escape         *)
  93. (*----------------------------------------------------------------------*)
  94.  
  95. PROCEDURE Read_Number_Or_ESC(     Ch        : CHAR;
  96.                                   Xpos      : INTEGER;
  97.                                   Xlen      : INTEGER;
  98.                               VAR SNumber   : AnyStr;
  99.                               VAR Pre_Str   : AnyStr;
  100.                               VAR Post_Str  : AnyStr;
  101.                               VAR Esc_Found : BOOLEAN;
  102.                               VAR Number    : INTEGER;
  103.                               VAR Entry_Str : AnyStr   );
  104.  
  105. (*----------------------------------------------------------------------*)
  106. (*                                                                      *)
  107. (*     Procedure:  Read_Number_Or_ESC                                   *)
  108. (*                                                                      *)
  109. (*     Purpose:    Reads in number and reports if escape hit.           *)
  110. (*                                                                      *)
  111. (*     Calling Sequence:                                                *)
  112. (*                                                                      *)
  113. (*        Read_Number_Or_ESC(     Ch        : CHAR;                     *)
  114. (*                                Xpos      : INTEGER;                  *)
  115. (*                                Xlen      : INTEGER;                  *)
  116. (*                            VAR SNumber   : AnyStr;                   *)
  117. (*                            VAR Pre_Str   : AnyStr;                   *)
  118. (*                            VAR Post_Str  : AnyStr;                   *)
  119. (*                            VAR Esc_Found : BOOLEAN;                  *)
  120. (*                            VAR Number    : INTEGER;                  *)
  121. (*                            VAR Entry_Str : AnyStr  );                *)
  122. (*                                                                      *)
  123. (*           Ch        --- First character in number (input)            *)
  124. (*           XPos      --- First column of answer                       *)
  125. (*           Xlen      --- Maximum columns in answer                    *)
  126. (*           SNumber   --- Full number if found                         *)
  127. (*           Pre_Str   --- Prefix string if any found                   *)
  128. (*           Post_Str  --- Postfix string if any found                  *)
  129. (*           Esc_Found --- Escape encountered                           *)
  130. (*           Number    --- Resultant number                             *)
  131. (*           Entry_Str --- Full text of string typed in                 *)
  132. (*                                                                      *)
  133. (*     Calls:                                                           *)
  134. (*                                                                      *)
  135. (*        Menu_Beep                                                     *)
  136. (*        Read_Kbd                                                      *)
  137. (*                                                                      *)
  138. (*----------------------------------------------------------------------*)
  139.  
  140. VAR
  141.    IX      : INTEGER;
  142.    IY      : INTEGER;
  143.    Ierr    : INTEGER;
  144.    A_Ch    : CHAR;
  145.  
  146. BEGIN (* Read_Number_Or_ESC *)
  147.  
  148.                                    (* Initialize arguments         *)
  149.    ESC_Found := FALSE;
  150.    SNumber   := Ch;
  151.    Pre_Str   := '';
  152.    Post_Str  := '';
  153.    Number    := 0;
  154.    Entry_Str := '';
  155.                                    (* Pick up the number, possibly  *)
  156.                                    (* with dialing prefix or ESC    *)
  157.  
  158.    TextColor( Menu_Text_Color );
  159.  
  160.    A_Ch := Edit_String( SNumber, Xlen, WhereX, WhereX + 1, WhereY,
  161.                         Xlen, FALSE, 0 );
  162.  
  163.                                    (* No number entered -- quit *)
  164.  
  165.    ESC_Found := ( A_Ch = CHR( ESC ) );
  166.  
  167.    IF ( LENGTH( SNumber ) <= 0 ) OR ( ESC_Found ) THEN EXIT;
  168.  
  169.                                    (* Save number as entered *)
  170.    Entry_Str := SNumber;
  171.                                    (* Remove prefix if any *)
  172.  
  173.    IF SNumber[1] IN ['+','-','!','@','#'] THEN
  174.       BEGIN
  175.          Pre_Str    := Phone_Prefix_Nos[ POS( SNumber[1], '+-!@#' ) ];
  176.          SNumber    := COPY( SNumber, 2, LENGTH( SNumber ) - 1 );
  177.       END;
  178.                                    (* Remove postfix if any *)
  179.  
  180.    IF SNumber[LENGTH(SNumber)] IN ['+','-','!','@','#'] THEN
  181.       BEGIN
  182.          Post_Str   := Phone_Prefix_Nos[ POS( SNumber[LENGTH(SNumber)],
  183.                                               '+-!@#' ) ];
  184.          SNumber    := COPY( SNumber, 1, LENGTH( SNumber ) - 1 );
  185.       END;
  186.  
  187.                                    (* Convert number *)
  188.    Number := 0;
  189.    Ierr   := 0;
  190.  
  191.    FOR IX := 1 TO LENGTH( SNumber ) DO
  192.       IF SNumber[IX] IN ['0'..'9'] THEN
  193.          Number := Number * 10 + ORD( SNumber[IX] ) - ORD('0')
  194.       ELSE IF ( NOT ( UpCase( SNumber[IX] ) IN ['M','G','*','#',',',' '] ) ) THEN
  195.          Ierr := 1;
  196.                                    (* If bad, beep and ignore. *)
  197.    IF ( Ierr > 0 ) THEN
  198.       BEGIN
  199.          Menu_Beep;
  200.          Number := 0;
  201.          EXIT;
  202.       END;
  203.  
  204. END   (* Read_Number_Or_ESC *);
  205.  
  206. (*----------------------------------------------------------------------*)
  207. (*       Update_Phone_File --- Update dialing directory file entry      *)
  208. (*----------------------------------------------------------------------*)
  209.  
  210. PROCEDURE Update_Phone_File( Phone_Entry_Data: Phone_Number_Record;
  211.                              Phone_Record    : INTEGER ) ;
  212.  
  213. (*----------------------------------------------------------------------*)
  214. (*                                                                      *)
  215. (*     Procedure:  Update_Phone_File                                    *)
  216. (*                                                                      *)
  217. (*     Purpose:    Updates entry in dialing directory file.             *)
  218. (*                                                                      *)
  219. (*     Calling Sequence:                                                *)
  220. (*                                                                      *)
  221. (*        Update_Phone_File( Phone_Entry_Data: Phone_Number_Record;     *)
  222. (*                           Phone_Record    : INTEGER );               *)
  223. (*                                                                      *)
  224. (*           Phone_Entry_Data --- data record for revised dialing entry *)
  225. (*           Phone_Record     --- record to be updated                  *)
  226. (*                                                                      *)
  227. (*----------------------------------------------------------------------*)
  228.  
  229. BEGIN (* Update_Phone_File *)
  230.                                    (* Update in-core list as well *)
  231.  
  232.    Dialing_Directory^[Phone_Record] := Phone_Entry_Data;
  233.    Any_Dialing_Changes              := TRUE;
  234.  
  235. END   (* Update_Phone_File *);
  236.  
  237. (*----------------------------------------------------------------------*)
  238. (*    Reset_Comm_Params --- Reset comm. parms. from dialing entry       *)
  239. (*----------------------------------------------------------------------*)
  240.  
  241. PROCEDURE Reset_Comm_Params( Phone_Entry_Data: Phone_Number_Record;
  242.                              Entry_Number    : INTEGER              ) ;
  243.  
  244. (*----------------------------------------------------------------------*)
  245. (*                                                                      *)
  246. (*     Procedure:  Reset_Comm_Params                                    *)
  247. (*                                                                      *)
  248. (*     Purpose:    Resets communications parameters (baud,parity,etc.)  *)
  249. (*                 according to selected dialing directory entry.       *)
  250. (*                                                                      *)
  251. (*     Calling Sequence:                                                *)
  252. (*                                                                      *)
  253. (*        Reset_Comm_Params( Phone_Entry_Data: Phone_Number_Record;     *)
  254. (*                           Entry_Number    : INTEGER             );   *)
  255. (*                                                                      *)
  256. (*           Phone_Entry_Data --- data record for a dialing entry       *)
  257. (*           Entry_Number     --- number of this entry in dialing dir.  *)
  258. (*                                                                      *)
  259. (*     Calls:                                                           *)
  260. (*                                                                      *)
  261. (*        Async_Reset_Port                                              *)
  262. (*                                                                      *)
  263. (*----------------------------------------------------------------------*)
  264.  
  265. VAR
  266.    Qerr: BOOLEAN;
  267.    S:    ShortStr;
  268.    I:    INTEGER;
  269.    J:    INTEGER;
  270.    T:    Terminal_Type;
  271.  
  272. BEGIN (* Reset_Comm_Params *)
  273.                                    (* Get parameters needed for dialing *)
  274.    WITH Phone_Entry_Data DO
  275.       BEGIN
  276.  
  277.          S := Phone_Baud;
  278.  
  279.          I := 0;
  280.  
  281.          FOR J := 1 TO LENGTH( S ) DO
  282.             IF S[J] IN ['0'..'9'] THEN
  283.                I := I * 10 + ORD( S[J] ) - ORD('0');
  284.  
  285.          Baud_Rate := I;
  286.  
  287.          Parity := Phone_Parity;
  288.  
  289.          Data_Bits := ORD( Phone_DataBits ) - ORD('0');
  290.  
  291.          Stop_Bits := ORD( Phone_StopBits ) - ORD('0');
  292.  
  293.          Reset_Comm_Port := TRUE;
  294.  
  295.          Async_Reset_Port( Comm_Port, Baud_Rate,
  296.                            Parity, Data_Bits, Stop_Bits );
  297.  
  298.          IF Do_Status_Line THEN
  299.             BEGIN
  300.                Set_Status_Line_Name( Short_Terminal_Name );
  301.                Write_To_Status_Line( Status_Line_Name, 1 );
  302.             END;
  303.  
  304.       END;
  305.  
  306. END   (* Reset_Comm_Params *);
  307.  
  308. (*----------------------------------------------------------------------*)
  309. (*    Reset_Other_Params --- Reset other parms. from dialing entry      *)
  310. (*----------------------------------------------------------------------*)
  311.  
  312. PROCEDURE Reset_Other_Params( Phone_Entry_Data: Phone_Number_Record;
  313.                               Entry_Number    : INTEGER              ) ;
  314.  
  315. (*----------------------------------------------------------------------*)
  316. (*                                                                      *)
  317. (*     Procedure:  Reset_Other_Params                                   *)
  318. (*                                                                      *)
  319. (*     Purpose:    Resets other params (transfer type, date/time, etc.) *)
  320. (*                 according to selected dialing directory entry.       *)
  321. (*                                                                      *)
  322. (*     Calling Sequence:                                                *)
  323. (*                                                                      *)
  324. (*        Reset_Other_Params( Phone_Entry_Data: Phone_Number_Record;    *)
  325. (*                            Entry_Number    : INTEGER             );  *)
  326. (*                                                                      *)
  327. (*           Phone_Entry_Data --- data record for a dialing entry       *)
  328. (*           Entry_Number     --- number of this entry in dialing dir.  *)
  329. (*                                                                      *)
  330. (*     Calls:                                                           *)
  331. (*                                                                      *)
  332. (*        CopySTOA                                                      *)
  333. (*                                                                      *)
  334. (*----------------------------------------------------------------------*)
  335.  
  336. VAR
  337.    Qerr: BOOLEAN;
  338.    S:    ShortStr;
  339.    I:    INTEGER;
  340.    J:    INTEGER;
  341.    T:    Terminal_Type;
  342.  
  343. BEGIN (* Reset_Other_Params *)
  344.  
  345.    WITH Phone_Entry_Data DO
  346.       BEGIN
  347.  
  348.          IF ( Phone_Echo <> ' ' ) THEN
  349.             Local_Echo := ( Phone_Echo = 'Y' );
  350.  
  351.          CASE Phone_BackSpace OF
  352.             'B': BEGIN
  353.                     BS_String      := CHR( BS );
  354.                     Ctrl_BS_String := CHR( DEL );
  355.                  END;
  356.             'D': BEGIN
  357.                     BS_String      := CHR( DEL );
  358.                     Ctrl_BS_String := CHR( BS  );
  359.                  END;
  360.             ELSE;
  361.          END;
  362.  
  363.          IF ( Phone_LineFeed <> ' ' ) THEN
  364.             Add_LF := ( Phone_LineFeed = 'Y' );
  365.  
  366.          IF ( Phone_Term_Type IN ['0'..'9', 'A'..'F'] ) THEN
  367.             Terminal_To_Emulate :=
  368.                Terminal_Type_List[ Hex_To_Dec( Phone_Term_Type , 0 ) ];
  369.  
  370.          IF ( Phone_Trans_Type <> '  ' ) THEN
  371.             BEGIN
  372.                FOR I := 1 TO Max_Transfer_Types DO
  373.                   IF ( Phone_Trans_Type = Trans_Type_Name[Transfers[I]] ) THEN
  374.                      Default_Transfer_Type := Transfers[I];
  375.             END;
  376.  
  377.          CopySToA( DialDateString, Phone_Last_Date, 8 );
  378.  
  379.          S := TimeString( TimeOfDay , Military_Time );
  380.  
  381.          IF ( S[1] = ' ' ) THEN
  382.             S[1] := '0';
  383.  
  384.          CopySToA( S, Phone_Last_Time, 8 );
  385.  
  386.          Dialing_Directory^[Entry_Number] := Phone_Entry_Data;
  387.          Any_Dialing_Changes              := TRUE;
  388.  
  389.       END;
  390.                                    (* Make sure script gets processed *)
  391.  
  392.    IF ( Phone_Entry_Data.Phone_Script <> '         ' ) AND
  393.       ( NOT Script_Learn_Mode                        ) AND
  394.       ( Allow_Script                                 ) THEN
  395.       BEGIN
  396.          Script_File_Name := Phone_Entry_Data.Phone_Script;
  397.          Read_In_Script   := TRUE;
  398.       END;
  399.  
  400. END   (* Reset_Other_Params *);
  401.  
  402. (*----------------------------------------------------------------------*)
  403. (*         Display_Phone_Numbers --- display dialing directory          *)
  404. (*----------------------------------------------------------------------*)
  405.  
  406. PROCEDURE Display_Phone_Numbers( VAR Entry_String: AnyStr;
  407.                                  VAR Phone_Number: AnyStr;
  408.                                  VAR Prefix_Str  : AnyStr;
  409.                                  VAR Postfix_Str : AnyStr;
  410.                                  VAR Esc_Hit     : BOOLEAN );
  411.  
  412. (*----------------------------------------------------------------------*)
  413. (*                                                                      *)
  414. (*     Procedure:  Display_Phone_Numbers                                *)
  415. (*                                                                      *)
  416. (*     Purpose:    Displays dialing directory and prompts for # to dial *)
  417. (*                                                                      *)
  418. (*     Calling Sequence:                                                *)
  419. (*                                                                      *)
  420. (*        Display_Phone_Numbers( VAR Entry_String: AnyStr               *)
  421. (*                               VAR Phone_Number: AnyStr;              *)
  422. (*                               VAR Prefix_Str  : AnyStr;              *)
  423. (*                               VAR Postfix_Str : AnyStr;              *)
  424. (*                               VAR Esc_Hit     : BOOLEAN );           *)
  425. (*                                                                      *)
  426. (*           Entry_String --- dialing # in character form               *)
  427. (*           Phone_Number --- phone number to dial (if any)             *)
  428. (*           Prefix_Str   --- prefix string to use                      *)
  429. (*           Postfix_Str  --- postfix string to use                     *)
  430. (*           Esc_Hit      --- TRUE if ESC hit to exit dialing           *)
  431. (*                                                                      *)
  432. (*     Calls:   Display_Directory_Page                                  *)
  433. (*              Dialer_Carrier_Detect                                   *)
  434. (*                                                                      *)
  435. (*----------------------------------------------------------------------*)
  436.  
  437. CONST
  438.    N_nos = 15                      (* No. of phone numbers displayed *);
  439.  
  440. VAR
  441.    Fixed_Entry  : Phone_Number_Record;
  442.    Low_Num      : INTEGER;
  443.    Hi_Num       : INTEGER;
  444.    Done         : BOOLEAN;
  445.    I            : INTEGER;
  446.    J            : INTEGER;
  447.    L            : INTEGER;
  448.    Dial_Func    : CHAR;
  449.    SNumber      : STRING[40];
  450.    Local_Save   : Saved_Screen_Ptr;
  451.    Local_Save_2 : Saved_Screen_Ptr;
  452.    Local_Save_3 : Saved_Screen_Ptr;
  453.    Qerr         : BOOLEAN;
  454.    XPos         : INTEGER;
  455.    YPos         : INTEGER;
  456.    ReDraw       : BOOLEAN;
  457.    Save_Pre     : ShortStr;
  458.    Save_Post    : ShortStr;
  459.    SS           : AnyStr;
  460.    Ch           : CHAR;
  461.    Q            : BOOLEAN;
  462.  
  463. (*----------------------------------------------------------------------*)
  464. (*     Display_One_Entry --- display one entry in phone directory       *)
  465. (*----------------------------------------------------------------------*)
  466.  
  467. PROCEDURE Display_One_Entry( Entry_No : INTEGER;
  468.                              Line_No  : INTEGER;
  469.                              Reverse  : BOOLEAN  );
  470.  
  471. VAR
  472.    Dial_Entry_Line : AnyStr;
  473.    BS_Str          : STRING[3];
  474.    Term_Str        : STRING[7];
  475.    Trans_Str       : STRING[12];
  476.    Date_Str        : STRING[8];
  477.    Time_Str        : STRING[8];
  478.    I               : INTEGER;
  479.    Ampm_Str        : STRING[2];
  480.  
  481. BEGIN (* Display_One_Entry *)
  482.  
  483.    WITH Dialing_Directory^[ Entry_No ] DO
  484.       BEGIN
  485.  
  486.          STR( Entry_No:3 , Dial_Entry_Line );
  487.  
  488.          Dial_Entry_Line := Dial_Entry_Line + '  ' + Phone_Name + '  ';
  489.  
  490.          CASE Phone_BackSpace OF
  491.             'B':  BS_Str := 'BS ';
  492.             'D':  BS_Str := 'DEL';
  493.             ELSE  BS_Str := '   ';
  494.          END (* CASE *);
  495.  
  496.          CASE Phone_Term_Type OF
  497.             '0'..'9':  BEGIN
  498.                           I        := ( ORD(Phone_Term_Type) - ORD('0') );
  499.                           Term_Str := Terminal_Name_List[ I ];
  500.                        END;
  501.             'A'..'F':  BEGIN
  502.                           I        := ( ORD(Phone_Term_Type) - ORD('A') );
  503.                           Term_Str := Terminal_Name_List[ I + 10 ];
  504.                        END;
  505.             ELSE       Term_Str := '   None';
  506.          END  (* CASE *);
  507.  
  508.          I := LENGTH( Term_Str );
  509.  
  510.          IF ( I < 7 ) THEN
  511.             Term_Str := DUPL( ' ' , 7 - I ) + Term_Str;
  512.  
  513.          IF ( Phone_Trans_Type = '  ' ) THEN
  514.             Trans_Str := '        None'
  515.          ELSE
  516.             BEGIN
  517.                FOR I := 1 TO Max_Transfer_Types DO
  518.                   IF ( Phone_Trans_Type = Trans_Type_Name[Transfers[I]] ) THEN
  519.                      Trans_Str := Transfer_Name_List[ I ];
  520.             END;
  521.  
  522.          IF Phone_Last_Date = '        ' THEN
  523.             Date_Str := '        '
  524.          ELSE
  525.             CASE Date_Format OF
  526.                YMD_Style: Date_Str := Phone_Last_Date;
  527.                DMY_Style: Date_Str := COPY( Phone_Last_Date, 7, 2 ) + '/' +
  528.                                       COPY( Phone_Last_Date, 4, 2 ) + '/' +
  529.                                       COPY( Phone_Last_Date, 1, 2 );
  530.                ELSE       Date_Str := COPY( Phone_Last_Date, 4, 5 ) + '/' +
  531.                                       COPY( Phone_Last_Date, 1, 2 );
  532.             END (* CASE *);
  533.  
  534.          IF Phone_Last_Time = '        ' THEN
  535.             Time_Str := '        '
  536.          ELSE
  537.             CASE Time_Format OF
  538.                Military_Time: Time_Str := Phone_Last_Time;
  539.                AMPM_Time    : BEGIN
  540.                                  I := ( ORD( Phone_Last_Time[1] ) - ORD('0') )
  541.                                       * 10 + ( ORD( Phone_Last_Time[2] ) - ORD('0') );
  542.                                  Adjust_Hour( I , Ampm_Str );
  543.                                  STR( I:2 , Time_Str );
  544.                                  Time_Str := Time_Str + ':' +
  545.                                              Phone_Last_Time[4] +
  546.                                              Phone_Last_Time[5] +
  547.                                              ' ' + Ampm_Str;
  548.                               END;
  549.                ELSE;
  550.             END (* CASE *);
  551.  
  552.          CASE Dialing_Page OF
  553.  
  554.             1:  Dial_Entry_Line := Dial_Entry_Line +
  555.                                    Phone_Number + '   ' + Phone_Baud + '    ' +
  556.                                    Phone_DataBits + '      ' + Phone_Parity +
  557.                                    '     ' + Phone_StopBits;
  558.  
  559.             2:  Dial_Entry_Line := Dial_Entry_Line +
  560.                                    '  ' + Phone_Echo +
  561.                                    '     ' + BS_Str + '     ' +
  562.                                    Phone_LineFeed  + '      ' +
  563.                                    Term_Str        + ' ' +
  564.                                    Trans_Str;
  565.  
  566.             3:  Dial_Entry_Line := Dial_Entry_Line +
  567.                                    Phone_Script    + '   '   +
  568.                                    Date_Str        + '     ' +
  569.                                    Time_Str;
  570.  
  571.          END (* CASE *);
  572.  
  573.          Dial_Entry_Line := Dial_Entry_Line +
  574.                             DUPL( ' ' , 75 - LENGTH( Dial_Entry_Line ) );
  575.  
  576.          IF ( NOT Reverse ) THEN
  577.             IF Write_Screen_Memory THEN
  578.                WriteSXY( Dial_Entry_Line, 2, Line_No + 2, Menu_Text_Color )
  579.             ELSE
  580.                BEGIN
  581.                   GoToXY( 1 , Line_No );
  582.                   WRITELN ( Dial_Entry_Line );
  583.                END
  584.          ELSE
  585.             BEGIN
  586.                GoToXY( 1 , 1 );
  587.                RvsVideoOn( Menu_Text_Color , BLACK );
  588.                WRITELN( Dial_Entry_Line );
  589.                RvsVideoOff( Menu_Text_Color , BLACK );
  590.             END;
  591.  
  592.       END (* WITH *);
  593.  
  594. END   (* Display_One_Entry *);
  595.  
  596. (*----------------------------------------------------------------------*)
  597. (*   Display_Directory_Page --- display a page of phone directory       *)
  598. (*----------------------------------------------------------------------*)
  599.  
  600. PROCEDURE Display_Directory_Page;
  601.  
  602. (*----------------------------------------------------------------------*)
  603. (*                                                                      *)
  604. (*     Procedure:  Display_Directory_Page                               *)
  605. (*                                                                      *)
  606. (*     Purpose:    Displays one page of dialing directory               *)
  607. (*                                                                      *)
  608. (*     Calling Sequence:                                                *)
  609. (*                                                                      *)
  610. (*        Display_Directory_Page;                                       *)
  611. (*                                                                      *)
  612. (*     Calls:   WriteSXY                                                *)
  613. (*                                                                      *)
  614. (*----------------------------------------------------------------------*)
  615.  
  616. VAR
  617.    I: INTEGER;
  618.    
  619. BEGIN (* Display_Directory_Page *)
  620.  
  621.    TextColor     ( Menu_Text_Color );
  622.    TextBackGround( BLACK );
  623.                                    (* Display entries              *)
  624.    L := 0;
  625.  
  626.    FOR I := Low_Num TO Hi_Num DO
  627.       BEGIN
  628.          L := L + 1;
  629.          Display_One_Entry( I , L , ( I = Low_Num ) );
  630.       END;
  631.                                    (* Blank out any remaining lines *)
  632.    FOR I := ( L + 1 ) TO N_Nos DO
  633.       BEGIN
  634.          GoToXY( 1 , I );
  635.          ClrEol;
  636.       END;
  637.  
  638. END   (* Display_Directory_Page *);
  639.  
  640. (*----------------------------------------------------------------------*)
  641. (*          Revise_Phone_Entry --- Revise phone directory entry         *)
  642. (*----------------------------------------------------------------------*)
  643.  
  644. PROCEDURE Revise_Phone_Entry;
  645.  
  646. (*----------------------------------------------------------------------*)
  647. (*                                                                      *)
  648. (*     Procedure:  Revise_Phone_Entry                                   *)
  649. (*                                                                      *)
  650. (*     Purpose:    Handles revision of dialing directory entry          *)
  651. (*                                                                      *)
  652. (*     Calling Sequence:                                                *)
  653. (*                                                                      *)
  654. (*        Revise_Phone_Entry;                                           *)
  655. (*                                                                      *)
  656. (*     Calls:   Save_Screen                                             *)
  657. (*              Draw_Menu_Frame                                         *)
  658. (*              Restore_Screen                                          *)
  659. (*                                                                      *)
  660. (*----------------------------------------------------------------------*)
  661.  
  662. VAR
  663.    J           : INTEGER;
  664.    Done        : BOOLEAN;
  665.    I           : INTEGER;
  666.    Quit        : BOOLEAN;
  667.    Ch          : CHAR;
  668.    S_No        : STRING[6];
  669.    Revise_Menu : Menu_Type;
  670.    Revise_Item : INTEGER;
  671.    SNumber     : STRING[30];
  672.    Changed_Any : BOOLEAN;
  673.    Entry_Str   : AnyStr;
  674.    X           : INTEGER;
  675.    Y           : INTEGER;
  676.  
  677. (*----------------------------------------------------------------------*)
  678. (*               Revise_Name --- Revise name of remote system           *)
  679. (*----------------------------------------------------------------------*)
  680.  
  681. PROCEDURE Revise_Name;
  682.  
  683. VAR
  684.    New_Name     : AnyStr;
  685.    Local_SaveIt : Saved_Screen_Ptr;
  686.  
  687. BEGIN (* Revise_Name *)
  688.  
  689.    Draw_Titled_Box( Local_SaveIt, 10, 10, 65, 14, 'Name' );
  690.  
  691.    PibTerm_Window( 11, 11, 64, 13 );
  692.  
  693.    TextColor( Menu_Text_Color_2 );
  694.  
  695.    GoToXY( 1 , 1 );
  696.  
  697.    New_name := Fixed_Entry.Phone_Name;
  698.  
  699.    WRITELN('Old Name: ', New_Name );
  700.    WRITE ('New Name: ');
  701.  
  702.    Saved_Insert_Mode := Edit_Insert_Mode;
  703.  
  704.    IF ( New_Name = Empty_Name ) THEN
  705.       Edit_Insert_Mode := FALSE;
  706.  
  707.    TextColor( Menu_Text_Color );
  708.  
  709.    Read_Edited_String( New_Name );
  710.  
  711.    Edit_Insert_Mode := Saved_Insert_Mode;
  712.  
  713.    IF ( ( LENGTH( New_Name ) > 0 ) AND ( New_Name <> CHR( ESC ) ) ) THEN
  714.       CopyStoA( New_Name , Fixed_Entry.Phone_Name , 25 );
  715.  
  716.    Restore_Screen( Local_SaveIt );
  717.  
  718. END   (* Revise_Name *);
  719.  
  720. (*----------------------------------------------------------------------*)
  721. (*           Revise_Number --- Revise number of remote system           *)
  722. (*----------------------------------------------------------------------*)
  723.  
  724. PROCEDURE Revise_Number;
  725.  
  726. VAR
  727.    New_Number   : AnyStr;
  728.    Local_SaveIt : Saved_Screen_Ptr;
  729.  
  730. BEGIN (* Revise_Number *)
  731.  
  732.    Draw_Titled_Box( Local_SaveIt, 10, 10, 65, 14, 'Number' );
  733.  
  734.    TextColor( Menu_Text_Color_2 );
  735.  
  736.    PibTerm_Window( 11, 11, 64, 13 );
  737.  
  738.    GoToXY( 1 , 1 );
  739.  
  740.    New_Number := LTrim( Fixed_Entry.Phone_Number );
  741.  
  742.    WRITELN('Old Number: ', New_Number );
  743.    WRITE ('New Number: ');
  744.  
  745.    Saved_Insert_Mode := Edit_Insert_Mode;
  746.  
  747.    IF ( New_Number = LTrim( Empty_Number ) ) THEN
  748.       Edit_Insert_Mode  := FALSE;
  749.  
  750.    TextColor( Menu_Text_Color );
  751.  
  752.    Read_Edited_String( New_Number );
  753.  
  754.    Edit_Insert_Mode  := Saved_Insert_Mode;
  755.  
  756.    IF ( New_Number <> CHR( ESC ) ) THEN
  757.       BEGIN
  758.  
  759.          New_Number := LTrim( Trim( New_Number ) );
  760.  
  761.          WHILE( POS( '#' , New_Number ) <> 0 ) DO
  762.             DELETE( New_Number, POS( '#' , New_Number ) , 1 );
  763.  
  764.          WHILE( New_Number[LENGTH( New_Number )] = '-' ) DO
  765.             DELETE( New_Number, LENGTH( New_Number ), 1 );
  766.  
  767.          IF ( LENGTH( New_Number ) > 0 ) THEN
  768.             CopyS2AR( New_Number , Fixed_Entry.Phone_Number , 15 );
  769.  
  770.       END;
  771.  
  772.    Restore_Screen( Local_SaveIt );
  773.  
  774. END   (* Revise_Number *);
  775.  
  776. (*----------------------------------------------------------------------*)
  777. (*               Revise_Baud_Rate --- Revise Baud Rate                  *)
  778. (*----------------------------------------------------------------------*)
  779.  
  780. PROCEDURE Revise_Baud_Rate;
  781.  
  782. VAR
  783.    Baud_Menu   : Menu_Type;
  784.    I           : INTEGER;
  785.    Default     : INTEGER;
  786.    B_Rate      : INTEGER;
  787.    Baud_String : AnyStr;
  788.    Baud_SVal   : STRING[5];
  789.  
  790. BEGIN (* Revise_Baud_Rate *)
  791.                                    (* Get current baud rate *)
  792.    B_Rate  := 0;
  793.    Default := 0;
  794.  
  795.    FOR I := 1 TO 5 DO
  796.       IF Fixed_Entry.Phone_Baud[I] IN ['0'..'9'] THEN
  797.          B_Rate := B_Rate * 10 + ORD( Fixed_Entry.Phone_Baud[I] ) - ORD('0');
  798.  
  799.    Baud_String := '';
  800.  
  801.    FOR I := 1 TO N_Baud_Rates DO
  802.       BEGIN
  803.          IF B_Rate = Baud_Rates[I] THEN
  804.             Default := I;
  805.          STR( Baud_Rates[I] , Baud_SVal );
  806.          Baud_String := Baud_String + Baud_SVal + ';';
  807.       END;
  808.  
  809.    IF ( Default = 0 ) THEN
  810.       Default := 5;
  811.                                    (* Display menu and get choice *)
  812.  
  813.    Make_And_Display_Menu( Baud_Menu, N_Baud_Rates, 10, 30, 0, 0, Default,
  814.                          'Choose Baud Rate: ',
  815.                          Baud_String,
  816.                          TRUE, TRUE, I );
  817.  
  818.    IF ( I > 0 ) THEN
  819.       BEGIN
  820.          STR( Baud_Rates[I] : 5 , S_No );
  821.          CopyS2AR( S_No , Fixed_Entry.Phone_Baud , 5 );
  822.       END;
  823.  
  824. END   (* Revise_Baud_Rate *);
  825.  
  826. (*----------------------------------------------------------------------*)
  827. (*            Revise_Parity --- Revise Parity for Communications        *)
  828. (*----------------------------------------------------------------------*)
  829.  
  830. PROCEDURE Revise_Parity;
  831.  
  832. CONST
  833.    Parities:   ARRAY[ 1 .. 5 ] OF Char
  834.                = ( 'E', 'O', 'N', 'M', 'S' );
  835.  
  836. VAR
  837.    Parity_Menu   : Menu_Type;
  838.    Default       : INTEGER;
  839.    I             : INTEGER;
  840.  
  841. BEGIN (* Revise_Parity *)
  842.                                    (* Get Current Parity *)
  843.    Default := 3;
  844.  
  845.    FOR I := 1 TO 5 DO
  846.       IF Fixed_Entry.Phone_Parity = Parities[I] THEN
  847.          Default := I;
  848.                                    (* Display menu and get choice *)
  849.  
  850.    Make_And_Display_Menu( Parity_Menu, 5, 10, 30, 0, 0, Default,
  851.                           'Choose parity: ',
  852.                           'Even;Odd;None;Mark;Space;',
  853.                           FALSE, TRUE, I );
  854.  
  855.    IF ( I > 0 ) THEN
  856.       Fixed_Entry.Phone_Parity := Parities[ I ];
  857.  
  858. END   (* Revise_Parity *);
  859.  
  860. (*----------------------------------------------------------------------*)
  861. (*          Revise_Stop_Bits --- Revise Stop Bits for Communications    *)
  862. (*----------------------------------------------------------------------*)
  863.  
  864. PROCEDURE Revise_Stop_Bits;
  865.  
  866. VAR
  867.    Stop_Menu   : Menu_Type;
  868.    I           : INTEGER;
  869.    Default     : INTEGER;
  870.  
  871. BEGIN (* Revise_Stop_Bits *)
  872.                                    (* Display menu and get choice *)
  873.  
  874.    IF ( Fixed_Entry.Phone_StopBits IN ['1',' '] ) THEN
  875.       Default := 1
  876.    ELSE
  877.       Default := 2;
  878.  
  879.    Make_And_Display_Menu( Stop_Menu, 2, 10, 30, 0, 0, Default,
  880.                           'Number of Stop Bits: ',
  881.                           '1;2;',
  882.                           FALSE, TRUE, I );
  883.  
  884.    IF ( I > 0 ) THEN
  885.       Fixed_Entry.Phone_StopBits := CHR( ORD('0') + I );
  886.  
  887. END   (* Revise_Stop_Bits *);
  888.  
  889. (*----------------------------------------------------------------------*)
  890. (*          Revise_Data_Bits --- Revise Data Bits for Communications    *)
  891. (*----------------------------------------------------------------------*)
  892.  
  893. PROCEDURE Revise_Data_Bits;
  894.  
  895. VAR
  896.    Bits_Menu   : Menu_Type;
  897.    I           : INTEGER;
  898.    Default     : INTEGER;
  899.  
  900. BEGIN (* Revise_Data_Bits *)
  901.                                    (* Display menu and get choice *)
  902.  
  903.    IF Fixed_Entry.Phone_DataBits = '7' THEN
  904.       Default := 1
  905.    ELSE
  906.       Default := 2;
  907.  
  908.    Make_And_Display_Menu( Bits_Menu, 2, 10, 30, 0, 0, Default,
  909.                           'Data Bits in Each Character: ',
  910.                           '7;8;',
  911.                           FALSE, TRUE, I );
  912.  
  913.    IF ( I > 0 ) THEN
  914.       Fixed_Entry.Phone_DataBits := CHR( ORD('6') + I );
  915.  
  916. END   (* Revise_Data_Bits *);
  917.  
  918. (*----------------------------------------------------------------------*)
  919. (*        Revise_BackSpace --- Revise type of Backspace/Delete          *)
  920. (*----------------------------------------------------------------------*)
  921.  
  922. PROCEDURE Revise_BackSpace;
  923.  
  924. VAR
  925.    BS_Menu   : Menu_Type;
  926.    I         : INTEGER;
  927.    Default   : INTEGER;
  928.  
  929. BEGIN (* Revise_BackSpace *)
  930.                                    (* Get current backspace setting *)
  931.  
  932.    IF ( Fixed_Entry.Phone_BackSpace = 'B' ) THEN
  933.       Default := 1
  934.    ELSE IF ( Fixed_Entry.Phone_BackSpace = 'D' ) THEN
  935.       Default := 2
  936.    ELSE
  937.       Default := 3;
  938.                                    (* Display menu and get choice *)
  939.  
  940.    Make_And_Display_Menu( BS_Menu, 3, 10, 30, 0, 0, Default,
  941.                           'Backspace key sends: ',
  942.                           'B)ackspace (ASCII 08);D)elete    (ASCII 127);' +
  943.                           'U)se extant definition',
  944.                           FALSE, TRUE, I );
  945.  
  946.    CASE I OF
  947.       1: Fixed_Entry.Phone_BackSpace := 'B';
  948.       2: Fixed_Entry.Phone_BackSpace := 'D';
  949.       3: Fixed_Entry.Phone_BackSpace := ' ';
  950.       ELSE;
  951.    END (* CASE *);
  952.  
  953. END   (* Revise_BackSpace *);
  954.  
  955. (*----------------------------------------------------------------------*)
  956. (*               Revise_Echo --- Revise local echo flag                 *)
  957. (*----------------------------------------------------------------------*)
  958.  
  959. PROCEDURE Revise_Echo;
  960.  
  961. VAR
  962.    Local_SaveIt : Saved_Screen_Ptr;
  963.    Echo_Flag    : BOOLEAN;
  964.  
  965. BEGIN (* Revise_Name *)
  966.  
  967.    Draw_Titled_Box( Local_SaveIt, 10, 10, 65, 14, 'Local Echo' );
  968.  
  969.    PibTerm_Window( 11, 11, 64, 13 );
  970.  
  971.    GoToXY( 1 , 1 );
  972.  
  973.    Echo_Flag := YesNo('Set local echo (Y/N)? ');
  974.  
  975.    IF Echo_Flag THEN
  976.       Fixed_Entry.Phone_Echo := 'Y'
  977.    ELSE
  978.       Fixed_Entry.Phone_Echo := 'N';
  979.  
  980.    Restore_Screen( Local_SaveIt );
  981.  
  982. END   (* Revise_Name *);
  983.  
  984. (*----------------------------------------------------------------------*)
  985. (*                Revise_LineFeeds --- Revise CR/LF definition          *)
  986. (*----------------------------------------------------------------------*)
  987.  
  988. PROCEDURE Revise_LineFeeds;
  989.  
  990. VAR
  991.    LF_Menu   : Menu_Type;
  992.    I         : INTEGER;
  993.    Default   : INTEGER;
  994.  
  995. BEGIN (* Revise_LineFeeds *)
  996.                                    (* Get CR/LF Key Use *)
  997.  
  998.    IF ( Fixed_Entry.Phone_LineFeed = 'Y' ) THEN
  999.       Default := 2
  1000.    ELSE
  1001.       Default := 1;
  1002.                                    (* Display menu and get choice *)
  1003.  
  1004.    Make_And_Display_Menu( LF_Menu, 2, 10, 30, 0, 0, Default,
  1005.                           'Incoming carriage return acts like: ',
  1006.                           'CR only;CR + LF;',
  1007.                           TRUE, TRUE, I );
  1008.  
  1009.     CASE I OF
  1010.        1: Fixed_Entry.Phone_LineFeed := 'N';
  1011.        2: Fixed_Entry.Phone_LineFeed := 'Y';
  1012.        ELSE
  1013.     END (* CASE *);
  1014.  
  1015. END   (* Revise_LineFeeds *);
  1016.  
  1017. (*----------------------------------------------------------------------*)
  1018. (*        Revise_Terminal_Type --- Get Type of Terminal to Emulate      *)
  1019. (*----------------------------------------------------------------------*)
  1020.  
  1021. PROCEDURE Revise_Terminal_Type;
  1022.  
  1023. VAR
  1024.    Emul_Menu   : Menu_Type;
  1025.    I           : INTEGER;
  1026.    J           : INTEGER;
  1027.    Default     : INTEGER;
  1028.  
  1029. BEGIN (* Revise_Terminal_Type *)
  1030.                                    (* Get current terminal type *)
  1031.  
  1032.    CASE Fixed_Entry.Phone_Term_Type OF
  1033.       '0'..'9':  Default := ( ORD(Fixed_Entry.Phone_Term_Type) - ORD('0') ) + 2;
  1034.       'A'..'F':  Default := ( ORD(Fixed_Entry.Phone_Term_Type) - ORD('A') ) + 12;
  1035.       ELSE       Default := 1;
  1036.    END  (* CASE *);
  1037.                                    (* Construct and display menu *)
  1038.  
  1039.    Make_And_Display_Menu( Emul_Menu, NumberTerminalTypes + 2, 8, 30, 0, 0,
  1040.                           Default,
  1041.                           'Terminal to Emulate: ',
  1042.                           'None;Dumb;VT52;ANSI;VT100;Gossip Mode;Host Mode;' +
  1043.                           'Tektronix 4010;ADM3a;ADM5;TV925;User1;User2;User3;' +
  1044.                           'User4;User5;',
  1045.                           TRUE, TRUE, I );
  1046.  
  1047.                                    (* Handle choice *)
  1048.    IF ( I <= 1 ) THEN
  1049.       Fixed_Entry.Phone_Term_Type := ' '
  1050.    ELSE IF ( ( I > 1 ) AND ( I < 12 ) ) THEN
  1051.       Fixed_Entry.Phone_Term_Type := CHR( ORD( '0' ) + I - 2  )
  1052.    ELSE
  1053.       Fixed_Entry.Phone_Term_Type := CHR( ORD( 'A' ) + I - 12 );
  1054.  
  1055. END   (* Revise_Terminal_Type *);
  1056.  
  1057. (*----------------------------------------------------------------------*)
  1058. (*   Revise_Transfer_Protocol --- Revised protocol for file transfers   *)
  1059. (*----------------------------------------------------------------------*)
  1060.  
  1061. PROCEDURE Revise_Transfer_Protocol;
  1062.  
  1063. VAR
  1064.    Transfer_Kind : Transfer_Type;
  1065.    Default       : Transfer_Type;
  1066.    I             : INTEGER;
  1067.  
  1068. BEGIN (* Revise_Transfer_Protocol *)
  1069.  
  1070.                                    (* Get current transfer type *)
  1071.    Default := None;
  1072.  
  1073.    FOR I := 1 TO Max_Transfer_Types DO
  1074.       IF ( Fixed_Entry.Phone_Trans_Type = Trans_Type_Name[Transfers[I]] ) THEN
  1075.          Default := Transfers[I];
  1076.  
  1077.    Display_Transfer_Types( 'Default transfer protocol: ',
  1078.                            Default,
  1079.                            FALSE,
  1080.                            2, 30, 40, 0, 25,
  1081.                            TRUE,
  1082.                            Transfer_Kind );
  1083.  
  1084.    IF ( Transfer_Kind = None ) THEN
  1085.       Fixed_Entry.Phone_Trans_Type := '  '
  1086.    ELSE
  1087.       Fixed_Entry.Phone_Trans_Type := Trans_Type_Name[Transfer_Kind];
  1088.  
  1089. END   (* Revise_Transfer_Protocol *);
  1090.  
  1091. (*----------------------------------------------------------------------*)
  1092. (*        Revise_Script --- Revise script to execute when dialing       *)
  1093. (*----------------------------------------------------------------------*)
  1094.  
  1095. PROCEDURE Revise_Script;
  1096.  
  1097. VAR
  1098.    New_Script   : AnyStr;
  1099.    Local_SaveIt : Saved_Screen_Ptr;
  1100.    I            : INTEGER;
  1101.    J            : INTEGER;
  1102.  
  1103. LABEL 1;
  1104.  
  1105. BEGIN (* Revise_Script *)
  1106.  
  1107.    Draw_Titled_Box( Local_SaveIt, 10, 10, 65, 14, '' );
  1108.  
  1109.    PibTerm_Window( 11, 11, 64, 13 );
  1110.  
  1111.    TextColor( Menu_Text_Color_2 );
  1112.  
  1113.    GoToXY( 1 , 1 );
  1114.  
  1115.    New_Script := Fixed_Entry.Phone_Script;
  1116.  
  1117.    WRITELN('Old Script Name: ', New_Script );
  1118.    WRITE ('New Script Name: ');
  1119.  
  1120.    TextColor( Menu_Text_Color );
  1121.  
  1122.    Read_Edited_String( New_Script );
  1123.  
  1124.    IF ( ( LENGTH( New_Script ) <= 0 ) OR ( New_Script = CHR( ESC ) ) ) THEN
  1125.       New_Script := ' '
  1126.    ELSE
  1127.       BEGIN
  1128.                                    (* Now strip off directory stuff *)
  1129.                                    (* from script name itself.      *)
  1130.          I := POS( '.', New_Script );
  1131.  
  1132.                                    (* Remove trailing filetype      *)
  1133.          IF ( I > 0 ) THEN
  1134.             New_Script := COPY( New_Script, 1, I - 1 );
  1135.  
  1136.                                    (* Remove drive indicator        *)
  1137.  
  1138.          I := POS( ':', New_Script );
  1139.  
  1140.          IF ( I > 0 ) THEN
  1141.             New_Script := COPY( New_Script, I + 1, LENGTH( New_Script ) - I );
  1142.  
  1143.                                    (* Remove directory indicator *)
  1144.  
  1145.          IF ( POS( '\', New_Script ) > 0 ) THEN
  1146.             BEGIN
  1147.                J := LENGTH( New_Script );
  1148.                FOR I := J DOWNTO 1 DO
  1149.                   IF ( New_Script[I] = '\' ) THEN
  1150.                      BEGIN
  1151.                         New_Script := COPY( New_Script, I + 1 , J - I );
  1152.                         GOTO 1;
  1153.                      END;
  1154.             END;
  1155.  
  1156.       END;
  1157.  
  1158. 1:
  1159.    CopySToA( New_Script , Fixed_Entry.Phone_Script , 9 );
  1160.  
  1161.    Restore_Screen( Local_SaveIt );
  1162.  
  1163. END   (* Revise_Script *);
  1164.  
  1165. (*----------------------------------------------------------------------*)
  1166.  
  1167. BEGIN (* Revise_Phone_Entry *)
  1168.                                    (* Get number to revise *)
  1169.  
  1170.    Draw_Titled_Box( Local_Save_2, 30, 10, 55, 14, 'Revise Dialing Entry');
  1171.  
  1172.    Quit := FALSE;
  1173.                                    (* Request the entry number *)
  1174.  
  1175.    TextColor( Menu_Text_Color_2 );
  1176.  
  1177.    WRITE('Entry to revise ? ');
  1178.  
  1179.    X       := WhereX;
  1180.    Y       := WhereY;
  1181.    SNumber := '';
  1182.  
  1183.    TextColor( Menu_Text_Color );
  1184.  
  1185.    Ch := Edit_String( SNumber, 30, X, X, Y, 30, FALSE, 0 );
  1186.  
  1187.                                    (* Exit if ESC entered *)
  1188.  
  1189.    IF ( Ch = CHR( ESC ) ) THEN
  1190.       BEGIN
  1191.          Restore_Screen( Local_Save_2 );
  1192.          EXIT;
  1193.       END;
  1194.                                    (* Take current entry if CR hit *)
  1195.  
  1196.    IF ( LENGTH( SNumber ) = 0 ) THEN
  1197.       J := Low_Num
  1198.    ELSE
  1199.       BEGIN
  1200.  
  1201.          J := 0;
  1202.  
  1203.          FOR X := 1 TO LENGTH( SNumber ) DO
  1204.             IF SNumber[X] IN ['0'..'9'] THEN
  1205.                J := J * 10 + ORD( SNumber[X] ) - ORD('0')
  1206.             ELSE
  1207.                BEGIN
  1208.                   WRITELN;
  1209.                   WRITELN('Invalid entry number.');
  1210.                   Window_Delay;
  1211.                   Restore_Screen( Local_Save_2 );
  1212.                   EXIT;
  1213.                END;
  1214.  
  1215.       END;
  1216.  
  1217.    IF ( ( J < 1 ) OR ( J > Dialing_Dir_Size ) ) THEN
  1218.       BEGIN
  1219.          WRITELN;
  1220.          WRITELN('No such entry.');
  1221.          Window_Delay;
  1222.          Restore_Screen( Local_Save_2 );
  1223.          EXIT;
  1224.       END
  1225.    ELSE                            (* Otherwise pick up entry's data *)
  1226.       BEGIN (* Entry exists *)
  1227.  
  1228.          Restore_Screen( Local_Save_2 );
  1229.  
  1230.          Fixed_Entry := Dialing_Directory^[ J ];
  1231.  
  1232.                                    (* Bring up revision window *)
  1233.          STR( J , S_No );
  1234.                                    (* Display items to revise *)
  1235.  
  1236.          Make_A_Menu( Revise_Menu, 14, 10, 30, 30, 0, 14,
  1237.                       'Revise Dialing Entry ' + S_No,
  1238.                       'All entries;Name;Number;Baud Rate;Parity;Data Bits;Stop Bits;' +
  1239.                       'Local Echo;Backspace;Add Linefeeds;Terminal Type;' +
  1240.                       'Transfer Type;Script Name;Quit;',
  1241.                       TRUE );
  1242.  
  1243.          Done        := FALSE;
  1244.          Revise_Item := 0;
  1245.          Changed_Any := FALSE;
  1246.                                    (* Select items to revise *)
  1247.          REPEAT
  1248.  
  1249.             Menu_Display_Choices( Revise_Menu );
  1250.  
  1251.             Revise_Item := Menu_Get_Choice( Revise_Menu , Erase_Menu );
  1252.             Changed_Any := Changed_Any OR ( Revise_Item <> 14 );
  1253.  
  1254.             CASE Revise_Item OF
  1255.  
  1256.                1:    BEGIN
  1257.                         Revise_Name;
  1258.                         Revise_Number;
  1259.                         Revise_Baud_Rate;
  1260.                         Revise_Data_Bits;
  1261.                         Revise_Parity;
  1262.                         Revise_Stop_Bits;
  1263.                         Revise_Echo;
  1264.                         Revise_BackSpace;
  1265.                         Revise_LineFeeds;
  1266.                         Revise_Terminal_Type;
  1267.                         Revise_Transfer_Protocol;
  1268.                         Revise_Script;
  1269.                         Done := TRUE;
  1270.                      END;
  1271.                2:    Revise_Name;
  1272.                3:    Revise_Number;
  1273.                4:    Revise_Baud_Rate;
  1274.                5:    Revise_Parity;
  1275.                6:    Revise_Data_Bits;
  1276.                7:    Revise_Stop_Bits;
  1277.                8:    Revise_Echo;
  1278.                9:    Revise_BackSpace;
  1279.                10:   Revise_LineFeeds;
  1280.                11:   Revise_Terminal_Type;
  1281.                12:   Revise_Transfer_Protocol;
  1282.                13:   Revise_Script;
  1283.                ELSE
  1284.                      Done := TRUE;
  1285.  
  1286.             END (* CASE *);
  1287.  
  1288.          UNTIL Done;
  1289.                                    (* Write revised entry back to *)
  1290.                                    (* phone directory file        *)
  1291.          IF Changed_Any THEN
  1292.             Update_Phone_File( Fixed_Entry, J );
  1293.  
  1294.       END (* Entry exists *);
  1295.  
  1296. END   (* Revise_Phone_Entry *);
  1297.  
  1298.