home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / pub / rt11pascal / rtpar.pas < prev    next >
Pascal/Delphi Source File  |  2020-01-01  |  34KB  |  1,506 lines

  1.   { Externals called by Parse }
  2.  
  3.   FUNCTION Exists({ Using } VAR s:string): { Returning } boolean;
  4.   EXTERNAL;
  5.  
  6.   { open (RT-11) -- open a file for reading or writing }
  7.   FUNCTION Sopen (VAR name : string; omode : integer) : filedesc;
  8.   EXTERNAL;
  9.  
  10.   { close (omsi) -- close a file }
  11.   PROCEDURE Sclose (fd : filedesc);
  12.   EXTERNAL;
  13.  
  14.   { close all files on exit }
  15.   PROCEDURE closeall;
  16.   EXTERNAL;
  17.  
  18.   PROCEDURE CtoS({ Using } x:cstring; { Returning } VAR s:string);
  19.     { convert constant to STIP string }
  20.   EXTERNAL;
  21.  
  22.   { getcf (UCB) -- get one character from file }
  23.   FUNCTION getcf (VAR c: character; fd : filedesc) : character;
  24.   EXTERNAL;
  25.  
  26.   { putcf (UCB) -- put a single character on file fd }
  27.   PROCEDURE putcf (c : character; fd : filedesc);
  28.   EXTERNAL;
  29.  
  30.   PROCEDURE GTLINE(VAR commandLine : string80);
  31.   EXTERNAL;
  32.  
  33.   { getarg (RT-11) -- copy n-th command line argument into s }
  34.   FUNCTION getarg (n : integer; VAR s : string;
  35.            maxs : integer) : boolean;
  36.   EXTERNAL;
  37.  
  38.   { number of arguments -- RT-11 }
  39.   FUNCTION nargs : integer;
  40.   EXTERNAL;
  41.  
  42.    { putstr (UCB) -- put out string on file }
  43.   PROCEDURE putstr (VAR s : string; f : filedesc);
  44.   EXTERNAL;
  45.  
  46.  
  47.   PROCEDURE PutCln({ Using } x:cstring;
  48.            { Using } fd:filedesc);
  49.     { output literal followed by NEWLINE }
  50.   EXTERNAL;
  51.  
  52.   PROCEDURE stiphalt; { used by external procedures for halt }
  53.   EXTERNAL;
  54.  
  55.   { fcopy -- copy file fin to file fout }
  56.   PROCEDURE fcopy (fin, fout : filedesc);
  57.   VAR
  58.     c : character;
  59.    BEGIN
  60.      WHILE (getcf(c, fin) <> ENDFILE) DO
  61.      putcf(c, fout)
  62.    END;
  63.  
  64.   PROCEDURE OverHd({ Using }  p,f: Stats;
  65.            { Returning } VAR o:integer);
  66.  
  67.     { Calculate OverHead as % }
  68.     { 0verHead := (p-f)*100/f }
  69.   VAR 
  70.      temp : real;
  71.    BEGIN
  72.     IF (f <> 0.0) THEN
  73.        BEGIN
  74.         temp := (p-f)*100/f;
  75.         o := round(temp);
  76.        END
  77.     ELSE
  78.         o := 0;
  79.    END;
  80.  
  81.   PROCEDURE CalRat({ Using } f: Stats;
  82.            { Using } t:integer;
  83.            { Returning } VAR r:integer);
  84.  
  85.     { Calculate Effective Baud Rate }
  86.     { Rate = f*10/t }
  87.   VAR
  88.     temp : real;    
  89.    BEGIN
  90.     IF t <> 0 THEN 
  91.        BEGIN
  92.         temp := f*10/t;
  93.         r := round(temp);
  94.        END
  95.     ELSE
  96.         r := 0;
  97.    END;
  98.  
  99.   { mustopen -- open file or die }
  100.   FUNCTION mustopen (VAR name : string; mode : integer) : filedesc;
  101.   VAR
  102.     fd : filedesc;
  103.    BEGIN
  104.      fd :=Sopen(name, mode);
  105.      IF (fd = IOERROR)
  106.       THEN
  107.        BEGIN
  108.      putstr(name, STDERR);
  109.      Putcln(': can''t open file   ',STDERR);
  110.      stiphalt;
  111.        END;
  112.      mustopen := fd
  113.    END;
  114.  
  115.   PROCEDURE Setargs;
  116.     { Set up list of filenames for KERMIT }
  117.   VAR
  118.     idx : 1.. MAXSTR;
  119.     i:integer;
  120.     fname : string;
  121.     junk : boolean;
  122.  
  123.    BEGIN
  124.  
  125.      cmdargs := 0;    {  initialize }
  126.      idx := 1;
  127.  
  128.      WHILE ( cmdlin[idx]<>ENDSTR) 
  129.      DO
  130.       BEGIN
  131.     WHILE (cmdlin[idx] = BLANK) DO
  132.     idx := idx+1;
  133.  
  134.     IF (cmdlin[idx]<>ENDSTR)
  135.      THEN
  136.       BEGIN
  137.         cmdargs := cmdargs+1;
  138.         cmdidx[cmdargs] := idx;
  139.         WHILE ((cmdlin[idx]<>ENDSTR)
  140.             AND (cmdlin[idx]<>BLANK)) DO
  141.            idx := idx+1;
  142.         IF (cmdlin[idx] <> ENDSTR) THEN
  143.         BEGIN 
  144.         cmdlin[idx] := ENDSTR;
  145.         idx := idx+1;
  146.         END;
  147.  
  148.         IF (cmdlin[cmdidx[cmdargs]] = LESS)
  149.          THEN
  150.           BEGIN
  151.         cmdidx[cmdargs] := cmdidx[cmdargs] + 1;
  152.         junk := getarg(cmdargs,fname,MAXSTR);
  153.         redirect[STDIN] := mustopen(fname,IOREAD);
  154.         cmdargs := cmdargs -1
  155.           END
  156.          ELSE
  157.          IF (cmdlin[cmdidx[cmdargs]] = GREATER)
  158.           THEN
  159.            BEGIN
  160.          cmdidx[cmdargs] := cmdidx[cmdargs] + 1;
  161.          junk := getarg(cmdargs,fname,MAXSTR);
  162.          redirect[STDOUT] := mustopen(fname,IOWRITE);
  163.          cmdargs := cmdargs -1
  164.            END
  165.  
  166.       END
  167.       END
  168.    END;
  169.   
  170.   { Beginning of PARSER }
  171.   { Based on the Parser in the VAX KERMIT by Bruce Pinn (UTCS) }
  172.  
  173.  
  174.   {$E+}
  175.   PROCEDURE PromptAndParseUser(VAR exitProgram : boolean;
  176.                    VAR RunType : command);
  177.   CONST
  178.  
  179.  
  180. { CONSTANTS for    Parser }
  181.  
  182.     NULL = -1;        
  183.     RANGENULL = -2;        
  184.  
  185.     INVALIDCOMMAND = 1;
  186.     INVALIDSETCOMMAND = 2;
  187.     INVALIDSHOWCOMMAND = 3;
  188.     NOTIMPLEMENTED = 4;
  189.     INVALIDFILESPEC    = 5;
  190.     INVALIDSETCVALUE =  6;
  191.     INVALIDSETDVALUE =  7;
  192.     INVALIDSETOVALUE = 8;
  193.     INVALIDSETRANGE    = 9;
  194.     SENDPARMS = 10;
  195.     RECEIVEPARMS = 11;
  196.     LOCALPARMS = 12;
  197.     BLANKLINE = 13;
  198.     NOHELPAVAILABLE    = 14;
  199.  
  200.     uSET = 3; 
  201.     uMSEND = 3; 
  202.     uMRECEIVE = 1; 
  203.     uSHOW =    2;
  204.     uSTATUS    = 2; 
  205.     uCONNECT = 1; 
  206.     uHELP =    1;
  207.     uQUESTION = 1; 
  208.     uEXIT =    1;
  209.     uQUIT =    1;
  210.     uSEND =    1;
  211.     uRECEIVE = 1; 
  212.     uDEBUGGING = 3;    
  213.     uFILEWARNING = 1; 
  214.     uFILERECORD = 5;
  215.     uEIGHTBIT = 2;
  216.     uLOCALECHO = 2;
  217.     uLINE =    2;
  218.     uESCAPE    = 2; 
  219.     uDELAY = 3;
  220.     uPACKETLENGTH =    3;
  221.     uPADDING = 4;
  222.     uPADCHAR = 4;
  223.     uTIMEOUT = 1;
  224.     uENDOFLINE = 1;    
  225.     uQUOTE = 1;
  226.     uALL = 1;
  227.     uON = 2;
  228.     uOFF = 2; 
  229.     uBADTOKEN = 1;
  230.     uCR = 2;
  231.     uLF = 1;
  232.     uCLF = 2;
  233.     uPARITY    = 1;
  234.     uEVEN =    1;
  235.     uODD = 1;
  236.     uNONE =    1;
  237.     uSPEED = 2;
  238.     uVERBOSE = 1;
  239.     uTESTING = 1;
  240.  
  241.  
  242.     oSET = 0;
  243.     oSHOW =    1;
  244.     oSTATUS    = 2;
  245.     oCONNECT = 3;
  246.     oHELP =    4;
  247.     oEXIT =    5;
  248.     oQUIT =    6;
  249.     oSEND =    7;
  250.     oRECEIVE = 8;
  251.     oDEBUGGING = 9;
  252.     oFILEWARNING = 10;
  253.     oLOCALECHO = 11;
  254.     oLINE =    12;
  255.     oESCAPE    = 13;
  256.     oDELAY = 14;
  257.     oPACKETLENGTH =    15;
  258.     oPADDING = 16;
  259.     oPADCHAR = 17;
  260.     oTIMEOUT = 18;
  261.     oENDOFLINE = 19;
  262.     oQUOTE = 20;
  263.     oQUESTIONM = 23;
  264.     oALL = 24;
  265.     oBADTOKEN = 25;
  266.     oFILERECORD = 26;
  267.     oCR = 27;
  268.     oLF = 28;
  269.     oCLF = 29;
  270.     oPARITY    = 30;
  271.     oSPEED = 34;
  272.     oVERBOSE = 35;
  273.     oTESTING = 36;
  274.     oEIGHTBIT = 37;
  275.  
  276.     oMAINTYPE = 1;
  277.     oSETTYPE = 2;
  278.     oSHOWTYPE = 3;
  279.     oSENDTYPE = 4;
  280.     oRECEIVETYPE = 5;
  281.     oDEBUGTYPE = 6;
  282.     oFILEWARNTYPE =    7;
  283.     oFILERECTYPE = 8;
  284.     oLOCECHOTYPE = 9;
  285.     oPARITYTYPE = 10;
  286.     oEIGHTBITTYPE =    11;
  287.  
  288.     DECIMAL    = 0;
  289.     SDECIMAL = 1;
  290.     OCTAL =    2;
  291.     CHRACTER = 3;
  292.     IDECIMAL = 4;
  293.  
  294.     o300BAUD = 300;
  295.     o600BAUD = 600;
  296.     o1200BAUD = 1200;
  297.     o2400BAUD = 2400;
  298.     o4800BAUD = 4800;
  299.     o9600BAUD = 9600;
  300.  
  301.     cBADTOKEN    = 'XX           ';
  302.     cSET        = 'SET          ';
  303.     cSHOW        = 'SHOW         ';
  304.     cSTATUS        = 'STATUS       ';
  305.     cCONNECT    = 'CONNECT      ';
  306.     cHELP        = 'HELP         ';
  307.     cEXIT        = 'EXIT         ';
  308.     cQUIT        = 'QUIT         ';
  309.     cQUESTION    = '?            ';
  310.     cSEND        = 'SEND         ';
  311.     cRECEIVE    = 'RECEIVE      ';
  312.     cDEBUGGING    = 'DEBUGGING    ';
  313.     cFILEWARNING    = 'FILE-WARNING ';
  314.     cLOCALECHO    = 'LOCAL-ECHO   ';
  315.     cLINE        = cBADTOKEN;
  316.     cESCAPE        = cBADTOKEN; 
  317.     cDELAY        = 'DELAY        ';
  318.     cPACKETLENGTH    = 'PACKET-LENGTH';
  319.     cPADDING    = 'PADDING      ';
  320.     cPADCHAR    = 'PADCHAR      ';
  321.     cTIMEOUT    = 'TIMEOUT      ';
  322.     cENDOFLINE    = 'END-OF-LINE  ';
  323.     cQUOTE        = 'QUOTE        ';
  324.     cALL        = 'ALL          ';
  325.     cON        = 'ON           ';
  326.     cOFF        = 'OFF          ';
  327.     cEIGHTBIT    = 'EIGHT-BIT    ';
  328.     cFILERECORD    = cBADTOKEN;
  329.     cCR        = 'CR           ';
  330.     cLF        = 'LF           ';
  331.     cCLF        = 'CLF          ';
  332.     cPARITY        = 'PARITY       ';
  333.     cEVEN        = 'EVEN         ';
  334.     cODD        = 'ODD          ';
  335.     cNONE        = 'NONE         ';
  336.     cSPEED        = cBADTOKEN;
  337.     cVERBOSE    = 'VERBOSE      ';
  338.     cTESTING    = 'TESTING      ';
  339.  
  340.   PROCEDURE SetEchoAndParity;
  341.    VAR
  342.       tempecho,tempparity : integer;
  343.   BEGIN
  344.  
  345.        IF (localEcho = oON)
  346.     THEN tempecho := 1
  347.     ELSE
  348.     tempecho := 0;
  349.  
  350.        IF parity = oNONE
  351.     THEN tempparity := -1
  352.     ELSE
  353.     IF parity = oEVEN
  354.      THEN  tempparity := 0
  355.      ELSE tempparity := 1;
  356.  
  357. {$C
  358.     .GLOBL    PARFLG
  359.     .GLOBL    ECHO
  360.     MOV    tempecho(SP),ECHO
  361.     MOV    tempparity(SP),PARFLG
  362. }
  363.    END;
  364.  
  365.  
  366.     {  Determine length of string. }
  367.     FUNCTION LenString(VAR tempStr : string80) : integer;
  368.     VAR
  369.       i : integer;
  370.       endofstring : boolean;
  371.      BEGIN
  372.        i := 80;
  373.        endofstring := false;
  374.        WHILE ((i >= 1) AND NOT(endofstring)) DO
  375.        IF (tempStr[i] = ' ')
  376.     THEN
  377.     i := i - 1
  378.     ELSE
  379.     endofstring := true;
  380.  
  381.        LenString := i;
  382.      END;
  383.  
  384.  
  385.  
  386.     {  Copy command line into temporary string until either EOS or blank }
  387.     PROCEDURE SkipBlanks(VAR command : string80;
  388.              VAR commandLen : integer);
  389.     VAR
  390.       i, k, j : integer;
  391.       endOfString : boolean;
  392.  
  393.      BEGIN
  394.  
  395.        i := 1;
  396.        endofString := false;
  397.        WHILE ((i <= commandLen) AND (NOT(endofString))) DO
  398.        IF (command[i] = ' ')
  399.     THEN
  400.     i := i + 1
  401.     ELSE
  402.     endofString := true;
  403.  
  404.        k := 1;
  405.        FOR j:=i TO commandLen DO
  406.     BEGIN
  407.       command[k] := command[j];
  408.       k := k + 1;
  409.     END;
  410.  
  411.        commandLen := commandLen - i;
  412.      END;
  413.  
  414.  
  415.     {  Copy command line into temporary string until either EOS or blank }
  416.     PROCEDURE CopyToken(VAR command : string80;
  417.             VAR commandLen : integer;
  418.             VAR tempStr : string13;
  419.             VAR totChars : integer);
  420.  
  421.  
  422.     VAR
  423.       i, j, k : integer;
  424.       noBlank : boolean;
  425.       tempToken : string80;
  426.  
  427.      BEGIN
  428.  
  429.        FOR i:=1 TO SMALLSIZE DO
  430.        tempStr[i] := ' ';
  431.  
  432.        i := 1;
  433.        noblank := true;
  434.        WHILE ((i <= commandLen) AND (noblank)) DO
  435.        IF (command[i] <> ' ')
  436.     THEN
  437.      BEGIN
  438.        tempToken[i] := command[i];
  439.        i := i + 1;
  440.      END
  441.     ELSE
  442.     noBlank := false;
  443.  
  444.        totChars := i - 1;
  445.  
  446.        IF (totChars <= SMALLSIZE)
  447.     THEN
  448.     FOR i:=1 TO totChars DO
  449.     tempStr[i] := tempToken[i]
  450.     ELSE
  451.      BEGIN
  452.        totChars := 2;
  453.        tempStr := cBADTOKEN;
  454.      END;
  455.  
  456.        k := 1;
  457.        FOR j:=(totChars+1) TO commandLen DO
  458.     BEGIN
  459.       command[k] := command[j];
  460.       k := k + 1;
  461.     END;
  462.  
  463.        commandLen := commandLen - (totChars - 1);
  464.      END;
  465.  
  466.  
  467.     {  Routine to compare strings for symbol comparison. }
  468.     FUNCTION CompareStr(command, symbol : string13;
  469.             commandLen, symbolLen : integer) : boolean;
  470.     VAR
  471.       i : integer;
  472.       sameStr : boolean;
  473.  
  474.      BEGIN
  475.        sameStr := true;
  476.        i := 1;
  477.        WHILE (sameStr AND (i <= commandLen)) DO
  478.        IF command[i] <> symbol[i]
  479.     THEN
  480.     sameStr := false
  481.     ELSE
  482.     i := i + 1;
  483.        i := i - 1;
  484.  
  485.        CompareStr := sameStr AND (i >= symbolLen);
  486.      END;
  487.  
  488.  
  489.  
  490.     PROCEDURE StrUpcase(VAR command : string80;
  491.             commandLen : integer);
  492.     VAR
  493.       i, diff : integer;
  494.  
  495.      BEGIN
  496.        diff := ord('a') - ord('A');
  497.        FOR i:=1 TO commandLen DO
  498.        IF ((command[i] >= 'a') AND (command[i] <= 'z'))
  499.     THEN
  500.     command[i] := chr(ord(command[i]) - diff);
  501.      END;
  502.  
  503.  
  504.     FUNCTION IsNumeric(    token : string13;
  505.                VAR tokLen, value : integer;
  506.                typeToken : integer) : boolean;
  507.  
  508.     VAR
  509.       goodChar : boolean;
  510.       upBound : char;
  511.       base, i : integer;
  512.  
  513.      BEGIN
  514.  
  515.        value := 0;
  516.        i := 1;
  517.        goodChar := true;
  518.        upBound := '9';
  519.        base := 10;
  520.        IF (typeToken = OCTAL)
  521.     THEN
  522.      BEGIN
  523.        upBound := '7';
  524.        base := 8;
  525.      END;
  526.  
  527.        WHILE ((i <= tokLen) AND (goodChar)) DO
  528.        IF ((token[i] >= '0') AND (token[i] <= upBound))
  529.     THEN
  530.      BEGIN
  531.        value := (value*base) + (ord(token[i]) - ord('0'));
  532.        i := i + 1;
  533.      END
  534.     ELSE
  535.      BEGIN
  536.        goodChar := false;
  537.        value := 0;
  538.      END;
  539.  
  540.        goodChar := goodChar AND (tokLen > 0);
  541.  
  542.        IF (typeToken = OCTAL)
  543.     THEN
  544.     IsNumeric := goodChar AND ((value >= 0) AND (value <= 31))
  545.     ELSE
  546.     IF (typeToken = SDECIMAL)
  547.      THEN
  548.      IsNumeric := goodChar AND ((value >= MINPACKETSIZE) AND
  549.                     (value <= MAXPACKETSIZE))
  550.      ELSE
  551.      IF (typeToken = IDECIMAL)
  552.       THEN
  553.       IsNumeric := goodChar AND ((value = o300BAUD) OR (value = o600BAUD) 
  554.                     OR  (value = o1200BAUD) 
  555.                     OR  (value = o2400BAUD) OR
  556.                      (value = o4800BAUD) OR (value = o9600BAUD))
  557.       ELSE
  558.       IsNumeric := goodChar AND ((value >= 0) AND
  559.                      (value <= 99))
  560.  
  561.      END;
  562.  
  563.  
  564.     {  Print the ? help writeln for main menu.  }
  565.     PROCEDURE PrintMainHelp;
  566.      BEGIN
  567.        writeln('  send <filename(s)>');
  568.        writeln('  receive [<filename>]');
  569.        writeln('  status');
  570.        writeln('  connect');
  571.        writeln('  set  <option>');
  572.        writeln('  show <option>');
  573.        writeln('  help');
  574.        writeln('  exit | quit');
  575.        writeln('  ?');
  576.      END;
  577.  
  578.  
  579.  
  580.     {  Print the ? help writeln for set menu. }
  581.     PROCEDURE PrintSetHelp;
  582.      BEGIN
  583.        writeln('  send  <option>');
  584.        writeln('  receive <option>');
  585.        writeln('  debugging <on | OFF>');
  586.        writeln('  file-warning <ON | off>');
  587.        { writeln('  filerecord <CLF | lf | cr>'); }
  588.        writeln('  eight-bit <ON | off>');
  589.        writeln('  local-echo <on | OFF>');
  590.        writeln('  parity <none | EVEN | odd>');
  591.        { writeln('  speed  <d>');
  592.         writeln('  line   <d>');
  593.     writeln('  escape <o>'); }
  594.        writeln('  delay  <d>');
  595.        writeln('  ?');
  596.      END;
  597.  
  598.  
  599.     {  Print the ? help writeln for show menu. }
  600.     PROCEDURE PrintShowHelp;
  601.      BEGIN
  602.        writeln('  send  <option>');
  603.        writeln('  receive <option>');
  604.        writeln('  debugging');
  605.        writeln('  file-warning');
  606.        { writeln('  filerecord'); }
  607.        writeln('  eight-bit');    
  608.        writeln('  local-echo');
  609.        { writeln('  line');
  610.     writeln('  escape'); }
  611.        writeln('  delay');
  612.        writeln('  all');
  613.        writeln('  ?');
  614.      END;
  615.  
  616.  
  617.     {  Print the ? help writeln for set send/receive menu. }
  618.     PROCEDURE PrintSetSendReceiveHelp;
  619.      BEGIN
  620.        writeln('  packet-length <d>');
  621.        writeln('  padding <d>');
  622.        writeln('  padchar <o>');
  623.        writeln('  timeout <d>');
  624.        writeln('  end-of-line   <o>');
  625.        writeln('  quote   <c>');
  626.      END;
  627.  
  628.  
  629.     {  Print the ? help writeln for show send/receive menu. }
  630.     PROCEDURE PrintShowSendReceiveHelp;
  631.      BEGIN
  632.        writeln('  packet-length');
  633.        writeln('  padding');
  634.        writeln('  padchar');
  635.        writeln('  timeout');
  636.        writeln('  end-of-line');
  637.        writeln('  quote');
  638.      END;
  639.  
  640.  
  641.     PROCEDURE PrintStatus;
  642.       {  Print the status of the last send/receive. }
  643.     CONST
  644.       STRWIDTH = 7;
  645.     VAR
  646.       overHead, effectiveRate : integer;
  647.      BEGIN
  648.        writeln('  Packets Sent =                ', NumSendPacks : STRWIDTH);
  649.        IF (oldRunType = Transmit)
  650.     THEN
  651.      BEGIN
  652.        writeln('  Number of ACK packets =       ', NumACKrecv : STRWIDTH);
  653.        writeln('  Number of NAK packets =       ', NumNAKrecv : STRWIDTH);
  654.        writeln('  Number of BAD packets =       ', NumBADrecv : STRWIDTH);
  655.      END
  656.     ELSE
  657.      BEGIN
  658.        writeln('  Number of ACK packets =       ', NumACK : STRWIDTH);
  659.        writeln('  Number of NAK packets =       ', NumNAK : STRWIDTH);
  660.      END;
  661.        writeln('  Data characters Sent =        ', ChInFileSend : STRWIDTH);
  662.        writeln('  Total characters Sent =       ', ChInPackSend : STRWIDTH);
  663.        OverHd(ChInPackSend, ChInFileSend, overHead);
  664.        writeln('  Overhead on Send Packets =    ', overHead : STRWIDTH, ' %');
  665.        writeln(' ');
  666.        writeln('  Packets Received =            ', NumRecvPacks : STRWIDTH);
  667.        writeln('  Data characters Received =    ', ChInFileRecv : STRWIDTH);
  668.        writeln('  Total characters Received =   ', ChInPackRecv : STRWIDTH);
  669.        OverHd(ChInPackRecv, ChInFileRecv, overHead);
  670.        writeln('  Overhead on Receive Packets = ', overHead : STRWIDTH, ' %');
  671.  
  672.        writeln;
  673.        writeln('  Run Time =                    ', RunTime : STRWIDTH);
  674.  
  675.        IF (oldRunType = Transmit)
  676.     THEN
  677.     CalRat(ChInFileSend, RunTime, effectiveRate)
  678.     ELSE
  679.     CalRat(ChInFileRecv, RunTime, effectiveRate);
  680.        writeln('  Effective Baud Rate =         ', effectiveRate : STRWIDTH);
  681.  
  682.      END;
  683.  
  684.  
  685.     {  Print the writeln specified. }
  686.     PROCEDURE PrintMessage(messageNumber : integer);
  687.  
  688.  
  689.      BEGIN
  690.        CASE messageNumber OF
  691.      NOTIMPLEMENTED :
  692.      writeln(' ? Not Implemented');
  693.      INVALIDCOMMAND :
  694.      writeln(' ? Invalid command');
  695.      INVALIDSETCOMMAND :
  696.      writeln(' ? Invalid set command');
  697.      INVALIDSHOWCOMMAND :
  698.      writeln(' ? Invalid show command');
  699.      INVALIDFILESPEC :
  700.      writeln(' ? Invalid file specification');
  701.      INVALIDSETCVALUE :
  702.      writeln(' ? Bad value: character');
  703.      INVALIDSETDVALUE :
  704.      writeln(' ? Bad value: decimal');
  705.      INVALIDSETOVALUE :
  706.      writeln(' ? Bad value: octal');
  707.      INVALIDSETRANGE :
  708.      writeln(' ? Value not in accepted range');
  709.      NOHELPAVAILABLE :
  710.      writeln(' ? Help file does not exist');
  711.      SENDPARMS :
  712.      writeln('Send Parameters:');
  713.      RECEIVEPARMS :
  714.      writeln('Receive Parameters:');
  715.      LOCALPARMS :
  716.      writeln('Local System Parameters:');
  717.      BLANKLINE :
  718.      writeln(' ');
  719.     END;
  720.      END;
  721.  
  722.  
  723.     {  Routine to type the help file. }
  724.     PROCEDURE PrintHelpFile;
  725.  
  726.     VAR
  727.       s : string;
  728.       hfile : filedesc;
  729.      BEGIN
  730.        CtoS( 'KERMIT.HLP          ',s);
  731.        IF Exists(s)
  732.     THEN
  733.      BEGIN
  734.        hfile := Sopen(s,IOREAD);
  735.        fcopy(hfile,STDOUT);
  736.        Sclose(hfile);
  737.      END
  738.     ELSE
  739.     PrintMessage(NOHELPAVAILABLE);
  740.      END;
  741.  
  742.  
  743.     {  Routine to print parameter values. }
  744.     PROCEDURE PrintParmValue(value, token : integer);
  745.  
  746.  
  747.      BEGIN
  748.        CASE token OF
  749.      oPACKETLENGTH :
  750.      writeln('  Packet-Length =         ', value : 2,' (dec)');
  751.      oPADDING :
  752.      writeln('  Padding =               ', value : 2,' (dec)');
  753.      oPADCHAR :
  754.      writeln('  Padding Character =     ', value : -2,' (oct)');
  755.      oTIMEOUT :
  756.      writeln('  Time-out length =       ', value : 2,' (sec)');
  757.      oENDOFLINE :
  758.      writeln('  End of Line Character = ', value : -2,' (oct)');
  759.      oQUOTE :
  760.      writeln('  Quote Character =       ', chr(value));
  761.      oFILERECORD :
  762.          {   begin
  763.           write('  End of Line for file =  ');
  764.           if (value = oCR) then
  765.           writeln('cr')
  766.           else if (value = oLF) then
  767.           writeln('lf')
  768.           else
  769.           writeln('cr/lf');
  770.       end } ;
  771.      oFILEWARNING :
  772.       BEGIN
  773.         write('  File Warning =          ');
  774.         IF (value = oOFF)
  775.          THEN
  776.          writeln('off')
  777.          ELSE
  778.          writeln('on');
  779.       END;
  780.      oEIGHTBIT :
  781.       BEGIN
  782.         write('  Eight-Bit Quoting =     ');
  783.         IF (value = oOFF)
  784.          THEN
  785.          writeln('off')
  786.          ELSE
  787.          writeln('on');
  788.       END;
  789.      oLOCALECHO :
  790.       BEGIN
  791.         write('  Local Echo =            ');
  792.         IF (value = oOFF)
  793.          THEN
  794.          writeln('off')
  795.          ELSE
  796.          writeln('on');
  797.       END;
  798.      oDELAY :
  799.      writeln('  Delay =                 ', value : 2,' (sec)');
  800.      oDEBUGGING :
  801.       BEGIN
  802.         write('  Debugging =             ');
  803.         IF NOT debug
  804.          THEN
  805.          writeln('off')
  806.          ELSE
  807.          writeln('on');
  808.         IF verbosity
  809.          THEN
  810.          writeln('  Verbosity');
  811.         IF OneWayOnly
  812.          THEN
  813.          writeln('  Test Mode');
  814.       END;
  815.      oPARITY :
  816.       BEGIN
  817.         write('  Parity =                ');
  818.         IF (value = oEVEN)
  819.          THEN
  820.          writeln('even')
  821.          ELSE
  822.          IF (value = oODD)
  823.           THEN
  824.           writeln('odd')
  825.           ELSE
  826.           writeln('none');
  827.       END;
  828.      oSPEED,
  829.      oESCAPE,
  830.      oLINE:
  831.      PrintMessage(NOTIMPLEMENTED);
  832.     END;
  833.      END;
  834.  
  835.  
  836.     {  Routine to scan for an appropriate value }
  837.     PROCEDURE ScanForValue(VAR command : string80;
  838.                VAR commandLen, value : integer;
  839.                convertType, commandType : integer);
  840.  
  841.  
  842.     VAR
  843.       tempToken : string13;
  844.       totChars  : integer;
  845.       xx : boolean;
  846.  
  847.      BEGIN
  848.  
  849.        CopyToken(command, commandLen, tempToken, totChars);
  850.  
  851.        CASE convertType OF
  852.      DECIMAL ,
  853.      SDECIMAL,
  854.      IDECIMAL :
  855.      IF NOT(IsNumeric(tempToken, totChars, value, convertType)) AND
  856.       (commandType <> oSHOWTYPE)
  857.       THEN
  858.        BEGIN
  859.          PrintMessage(INVALIDSETDVALUE);
  860.          value := RANGENULL;
  861.        END;
  862.      OCTAL :
  863.      IF NOT(IsNumeric(tempToken, totChars, value, convertType)) AND
  864.       (commandType <> oSHOWTYPE)
  865.       THEN
  866.        BEGIN
  867.          PrintMessage(INVALIDSETOVALUE);
  868.          value := RANGENULL;
  869.        END;
  870.      CHRACTER :
  871.      IF (totChars = 1)
  872.       THEN
  873.       value := ord(tempToken[1])
  874.       ELSE
  875.       IF (commandType <> oSHOWTYPE)
  876.        THEN
  877.         BEGIN
  878.           PrintMessage(INVALIDSETCVALUE);
  879.           value := RANGENULL;
  880.         END;
  881.     END;
  882.      END;
  883.  
  884.  
  885.     {  Determine if we have a valid number, and if so set it.  }
  886.     PROCEDURE TestAndSetValue(VAR value, numberToSet : integer;
  887.                   token, commandType : integer);
  888.  
  889.  
  890.      BEGIN
  891.        IF (commandType = oSHOWTYPE)
  892.     THEN
  893.     PrintParmValue(numberToSet, token)
  894.     ELSE
  895.     IF (value = NULL)
  896.      THEN
  897.       BEGIN
  898.         PrintMessage(INVALIDSETCOMMAND);
  899.       END
  900.      ELSE
  901.      IF (value <> RANGENULL)
  902.       THEN
  903.       numberToSet := value;
  904.      END;
  905.  
  906.  
  907.     {  Routine to print the value of all parameters in program.  }
  908.     PROCEDURE PrintAllParameters;
  909.  
  910.  
  911.      BEGIN
  912.        PrintMessage(SENDPARMS);
  913.        PrintParmValue(SizeSend, oPACKETLENGTH);
  914.        PrintParmValue(Pad, oPADDING);
  915.        PrintParmValue(PadChar, oPADCHAR);
  916.        PrintParmValue(TheirTimeOut, oTIMEOUT);
  917.        PrintParmValue(SendEOL, oENDOFLINE);
  918.        PrintParmValue(SendQuote, oQUOTE);
  919.  
  920.        PrintMessage(RECEIVEPARMS);
  921.        PrintParmValue(SizeRecv, oPACKETLENGTH);
  922.        PrintParmValue(MyPad, oPADDING);
  923.        PrintParmValue(MyPadChar, oPADCHAR);
  924.        PrintParmValue(MyTimeOut, oTIMEOUT);
  925.        PrintParmValue(MyEOL, oENDOFLINE);
  926.        PrintParmValue(MyQuote, oQUOTE);
  927.  
  928.        PrintMessage(BLANKLINE);
  929.        PrintMessage(LOCALPARMS);
  930.        PrintParmValue(fileWarn, oFILEWARNING);
  931.        { PrintParmValue(fileEol, oFILERECORD);  }
  932.        PrintParmValue(eightBitQuoting,oEIGHTBIT);
  933.        PrintParmValue(localEcho, oLOCALECHO);
  934.        PrintParmValue(parity, oPARITY);
  935.        { PrintParmValue(lSpeed, oSPEED); }
  936.        PrintParmValue(Delay, oDELAY);
  937.        PrintParmValue(debugging, oDEBUGGING);
  938.      END;
  939.  
  940.  
  941.     {  Routine to parse send/receive command for file name or wildcard des. }
  942.     PROCEDURE ParseSendReceiveCommand(VAR commandLine : string80;
  943.                       VAR commandLen : integer;
  944.                       token : integer);
  945.  
  946.     VAR
  947.       dummy ,gotafile : boolean;
  948.       i : integer;
  949.       tempfile : string;    
  950.      BEGIN
  951.  
  952.        IF ((commandLine[1] <> ' ') AND (commandLen > 0))
  953.     THEN
  954.      BEGIN
  955.        { copy and set up arguments }
  956.  
  957.        FOR i := 1 TO commandLen DO
  958.        cmdlin[i] := ord(commandLine[i]);
  959.        cmdlin[commandLen + 1] := ENDSTR;
  960.        setargs;
  961.  
  962.        { Check to see if we have any files to send }
  963.  
  964.        gotafile := false;
  965.        nextarg := 1;
  966.  
  967.        WHILE((NOT gotafile) AND (nextarg <= nargs)) DO
  968.         BEGIN
  969.           dummy := getarg(nextarg,tempfile,MAXSTR);
  970.           gotafile := Exists(tempfile);
  971.           nextarg := nextarg + 1;
  972.         END;
  973.                 
  974.        nextarg := 1;
  975.  
  976.        CASE token OF
  977.          oSEND:
  978.              IF gotafile THEN 
  979.                 sFileSpec := oON
  980.              ELSE
  981.                BEGIN
  982.                 sFileSpec := oOFF;
  983.                     PrintMessage(INVALIDFILESPEC);
  984.                END; 
  985.          ELSE
  986.          rFileSpec := oON;
  987.         END;
  988.      END
  989.     ELSE
  990.     IF (token = oSEND)
  991.      THEN
  992.       BEGIN
  993.         sFileSpec := oOFF;
  994.         PrintMessage(INVALIDFILESPEC);
  995.       END
  996.      ELSE
  997.      rFileSpec := oOFF;
  998.  
  999.      END;
  1000.  
  1001.  
  1002.     {  Get a valid token form the command line and return it. }
  1003.     PROCEDURE ScanForToken(VAR commandLine : string80;
  1004.                VAR commandLen, token : integer;
  1005.                typeToken : integer);
  1006.  
  1007.  
  1008.     VAR
  1009.       tempToken : string13;
  1010.       totChars : integer;
  1011.  
  1012.      BEGIN
  1013.  
  1014.        CopyToken(commandLine, commandLen, tempToken, totChars);
  1015.        SkipBlanks(commandLine, commandLen);
  1016.  
  1017.        token := NULL;
  1018.        IF (totChars <> 0)
  1019.     THEN
  1020.     CASE typeToken OF
  1021.       oMAINTYPE :
  1022.       IF (CompareStr(tempToken, cSET, totChars, uSET))
  1023.        THEN
  1024.        token := oSET
  1025.        ELSE
  1026.        IF (CompareStr(tempToken, cSHOW, totChars, uSHOW))
  1027.         THEN
  1028.         token := oSHOW
  1029.         ELSE
  1030.         IF (CompareStr(tempToken, cSTATUS, totChars, uSTATUS))
  1031.          THEN
  1032.          token := oSTATUS
  1033.          ELSE
  1034.          IF (CompareStr(tempToken, cCONNECT, totChars, uCONNECT))
  1035.           THEN
  1036.           token := oCONNECT
  1037.           ELSE
  1038.           IF (CompareStr(tempToken, cSEND, totChars, uMSEND))
  1039.            THEN
  1040.            token := oSEND
  1041.            ELSE
  1042.            IF (CompareStr(tempToken, cRECEIVE, totChars, uMRECEIVE))
  1043.         THEN
  1044.         token := oRECEIVE
  1045.         ELSE
  1046.         IF (CompareStr(tempToken, cHELP, totChars, uHELP))
  1047.          THEN
  1048.          token := oHELP
  1049.          ELSE
  1050.          IF (CompareStr(tempToken, cQUESTION, totChars, uQUESTION))
  1051.           THEN
  1052.           token := oQUESTIONM
  1053.           ELSE
  1054.           IF (CompareStr(tempToken, cQUIT, totChars, uQUIT))
  1055.            THEN
  1056.            token := oQUIT
  1057.            ELSE
  1058.            IF (CompareStr(tempToken, cEXIT, totChars, uEXIT))
  1059.             THEN
  1060.             token := oEXIT;
  1061.  
  1062.       oSETTYPE,
  1063.       oSHOWTYPE :
  1064.       IF (CompareStr(tempToken, cSEND, totChars, uSEND))
  1065.        THEN
  1066.        token := oSEND
  1067.        ELSE
  1068.        IF (CompareStr(tempToken, cRECEIVE, totChars, uRECEIVE))
  1069.         THEN
  1070.         token := oRECEIVE
  1071.         ELSE
  1072.         IF (CompareStr(tempToken, cDEBUGGING, totChars, uDEBUGGING))
  1073.          THEN
  1074.          token := oDEBUGGING
  1075.          ELSE
  1076.          IF (CompareStr(tempToken, cFILEWARNING, totChars, uFILEWARNING))
  1077.           THEN
  1078.           token := oFILEWARNING
  1079.           ELSE
  1080.           IF (CompareStr(tempToken, cFILERECORD, totChars, uFILERECORD))
  1081.            THEN
  1082.            token := oFILERECORD
  1083.            ELSE
  1084.            IF (CompareStr(tempToken, cLOCALECHO, totChars, uLOCALECHO))
  1085.         THEN
  1086.         token := oLOCALECHO
  1087.         ELSE
  1088.            IF (CompareStr(tempToken, cEIGHTBIT, totChars, uEIGHTBIT))
  1089.         THEN
  1090.         token := oEIGHTBIT
  1091.         ELSE
  1092.         IF (CompareStr(tempToken, cLINE, totChars, uLINE))
  1093.          THEN
  1094.          token := oLINE
  1095.          ELSE
  1096.          IF (CompareStr(tempToken, cESCAPE, totChars, uESCAPE))
  1097.           THEN
  1098.           token := oESCAPE
  1099.           ELSE
  1100.           IF (CompareStr(tempToken, cDELAY, totChars, uDELAY))
  1101.            THEN
  1102.            token := oDELAY
  1103.            ELSE
  1104.            IF (CompareStr(tempToken, cPARITY, totChars, uPARITY))
  1105.             THEN
  1106.             token := oPARITY
  1107.             ELSE
  1108.             IF (CompareStr(temptoken, cSPEED, totChars, uSPEED))
  1109.              THEN
  1110.              token := oSPEED
  1111.              ELSE
  1112.              IF (CompareStr(tempToken, cALL, totChars, uALL))
  1113.               THEN
  1114.               token := oALL
  1115.               ELSE
  1116.               IF (CompareStr(tempToken, cQUESTION, totChars, uQUESTION))
  1117.                THEN
  1118.                token := oQUESTIONM;
  1119.  
  1120.       oSENDTYPE,
  1121.       oRECEIVETYPE :
  1122.       IF (CompareStr(tempToken, cPACKETLENGTH, totChars, uPACKETLENGTH))
  1123.        THEN
  1124.        token := oPACKETLENGTH
  1125.        ELSE
  1126.        IF (CompareStr(tempToken, cPADDING, totChars, uPADDING))
  1127.         THEN
  1128.         token := oPADDING
  1129.         ELSE
  1130.         IF (CompareStr(tempToken, cQUESTION, totChars, uQUESTION))
  1131.          THEN
  1132.          token := oQUESTIONM
  1133.          ELSE
  1134.          IF (CompareStr(tempToken, cPADCHAR, totChars, uPADCHAR))
  1135.           THEN
  1136.           token := oPADCHAR
  1137.           ELSE
  1138.           IF (CompareStr(tempToken, cTIMEOUT, totChars, uTIMEOUT))
  1139.            THEN
  1140.            token := oTIMEOUT
  1141.            ELSE
  1142.            IF (CompareStr(tempToken, cENDOFLINE, totChars, uENDOFLINE))
  1143.         THEN
  1144.         token := oENDOFLINE
  1145.         ELSE
  1146.         IF (CompareStr(tempToken, cQUOTE, totChars, uQUOTE))
  1147.          THEN
  1148.          token := oQUOTE;
  1149.  
  1150.       oDEBUGTYPE:
  1151.       IF (CompareStr(tempToken, cOFF, totChars, uOFF))
  1152.        THEN
  1153.         BEGIN
  1154.           debug := false;
  1155.           verbosity := false;
  1156.           OneWayOnly := false;
  1157.         END
  1158.        ELSE
  1159.           IF (CompareStr(tempToken, cON, totChars, uON))
  1160.         THEN
  1161.         debug := true
  1162.         ELSE
  1163.            IF (CompareStr(tempToken, cVERBOSE, totChars, uVERBOSE))
  1164.          THEN
  1165.          verbosity := true
  1166.          ELSE
  1167.            IF (CompareStr(tempToken, cTESTING, totChars, uTESTING))
  1168.           THEN    
  1169.           OneWayOnly := true;
  1170.       oFILEWARNTYPE,
  1171.     oEIGHTBITTYPE,
  1172.       oLOCECHOTYPE :
  1173.       IF (CompareStr(tempToken, cON, totChars, uON))
  1174.        THEN
  1175.        token := oON
  1176.        ELSE
  1177.        IF (CompareStr(tempToken, cOFF, totChars, uOFF))
  1178.         THEN
  1179.         token := oOFF;
  1180.  
  1181.       oFILERECTYPE :
  1182.           {       if (CompareStr(tempToken, cCR, totChars, uCR)) then
  1183.            token := oCR
  1184.            else if (CompareStr(tempToken, cLF, totChars, uLF)) then
  1185.            token := oLF
  1186.            else if (CompareStr(tempToken, cCLF, totChars, uCLF)) then
  1187.        token := oCLF } ;
  1188.  
  1189.       oPARITYTYPE :
  1190.       IF (CompareStr(tempToken, cEVEN, totChars, uEVEN))
  1191.        THEN
  1192.        token := oEVEN
  1193.        ELSE
  1194.        IF (CompareStr(tempToken, cODD, totChars, uODD))
  1195.         THEN
  1196.         token := oODD
  1197.         ELSE
  1198.         IF (CompareStr(tempToken, cNONE, totChars, uNONE))
  1199.          THEN
  1200.          token := oNONE;
  1201.      END;
  1202.  
  1203.      END;
  1204.  
  1205.  
  1206.     {  Parse the set and show command and the proceed to set appropriate
  1207.      kermit variables.                                                 }
  1208.     PROCEDURE ParseSetShowCommand(VAR commandLine : string80;
  1209.                   VAR commandLen : integer;
  1210.                   commandType : integer);
  1211.  
  1212.     VAR
  1213.       token, value : integer;
  1214.  
  1215.      BEGIN
  1216.        ScanForToken(commandLine, commandLen, token, commandType);
  1217.  
  1218.        CASE token OF
  1219.      oSEND    :
  1220.       BEGIN
  1221.         ScanForToken(commandLine, commandLen, token, oSENDTYPE);
  1222.         CASE token OF
  1223.           oPACKETLENGTH :
  1224.            BEGIN
  1225.          ScanForValue(commandLine, commandLen, value,
  1226.                   SDECIMAL, commandType);
  1227.          TestAndSetValue(value, SizeSend, token,
  1228.                  commandType);
  1229.            END;
  1230.           oPADDING :
  1231.            BEGIN
  1232.          ScanForValue(commandLine, commandLen, value,
  1233.                   DECIMAL, commandType);
  1234.          TestAndSetValue(value, Pad, token, commandType);
  1235.            END;
  1236.           oPADCHAR :
  1237.            BEGIN
  1238.          ScanForValue(commandLine, commandLen, value,
  1239.                   OCTAL, commandType);
  1240.          TestAndSetValue(value, PadChar, token,
  1241.                  commandType);
  1242.            END;
  1243.           oTIMEOUT :
  1244.            BEGIN
  1245.          ScanForValue(commandLine, commandLen, value,
  1246.                   DECIMAL, commandType);
  1247.          TestAndSetValue(value, TheirTimeOut, token,
  1248.                  commandType);
  1249.            END;
  1250.           oENDOFLINE :
  1251.            BEGIN
  1252.          ScanForValue(commandLine, commandLen, value,
  1253.                   OCTAL, commandType);
  1254.          TestAndSetValue(value, SendEol, token,
  1255.                  commandType);
  1256.            END;
  1257.           oQUOTE :
  1258.            BEGIN
  1259.          ScanForValue(commandLine, commandLen, value,
  1260.                   CHRACTER, commandType);
  1261.          TestAndSetValue(value, SendQuote, token,
  1262.                  commandType);
  1263.            END;
  1264.           oQUESTIONM :
  1265.           IF (commandType = oSETTYPE)
  1266.            THEN
  1267.            PrintSetSendReceiveHelp
  1268.            ELSE
  1269.            PrintShowSendReceiveHelp;
  1270.           ELSE
  1271.           IF (commandType = oSETTYPE)
  1272.            THEN
  1273.            PrintMessage(INVALIDSETCOMMAND)
  1274.            ELSE
  1275.            PrintMessage(INVALIDSHOWCOMMAND);
  1276.          END;
  1277.       END;
  1278.  
  1279.      oRECEIVE :
  1280.       BEGIN
  1281.         ScanForToken(commandLine, commandLen, token, oRECEIVETYPE);
  1282.         CASE token OF
  1283.           oPACKETLENGTH :
  1284.            BEGIN
  1285.          ScanForValue(commandLine, commandLen, value,
  1286.                   SDECIMAL, commandType);
  1287.          TestAndSetValue(value, SizeRecv, token,
  1288.                  commandType);
  1289.            END;
  1290.           oPADDING :
  1291.            BEGIN
  1292.          ScanForValue(commandLine, commandLen, value,
  1293.                   DECIMAL, commandType);
  1294.          TestAndSetValue(value, MyPad, token, commandType);
  1295.            END;
  1296.           oPADCHAR :
  1297.            BEGIN
  1298.          ScanForValue(commandLine, commandLen, value,
  1299.                   OCTAL, commandType);
  1300.          TestAndSetValue(value, MyPadChar, token,
  1301.                  commandType);
  1302.            END;
  1303.           oTIMEOUT :
  1304.            BEGIN
  1305.          ScanForValue(commandLine, commandLen, value,
  1306.                   DECIMAL, commandType);
  1307.          TestAndSetValue(value, MyTimeOut, token,
  1308.                  commandType);
  1309.            END;
  1310.           oENDOFLINE :
  1311.            BEGIN
  1312.          ScanForValue(commandLine, commandLen, value,
  1313.                   OCTAL, commandType);
  1314.          TestAndSetValue(value, MyEol, token, commandType);
  1315.            END;
  1316.           oQUOTE :
  1317.            BEGIN
  1318.          ScanForValue(commandLine, commandLen, value,
  1319.                   CHRACTER, commandType);
  1320.          TestAndSetValue(value, MyQuote, token,
  1321.                  commandType);
  1322.            END;
  1323.           oQUESTIONM :
  1324.           IF (commandType = oSETTYPE)
  1325.            THEN
  1326.            PrintSetSendReceiveHelp
  1327.            ELSE
  1328.            PrintShowSendReceiveHelp;
  1329.           ELSE
  1330.           IF (commandType = oSETTYPE)
  1331.            THEN
  1332.            PrintMessage(INVALIDSETCOMMAND)
  1333.            ELSE
  1334.            PrintMessage(INVALIDSHOWCOMMAND);
  1335.          END;
  1336.       END;
  1337.  
  1338.      oDEBUGGING :
  1339.       BEGIN
  1340.         ScanForToken(commandLine, commandLen, value, oDEBUGTYPE);
  1341.       END;
  1342.      oFILEWARNING :
  1343.       BEGIN
  1344.         ScanForToken(commandLine, commandLen, value, oFILEWARNTYPE);
  1345.         TestAndSetValue(value, fileWarn, token, commandType);
  1346.       END;
  1347.      oFILERECORD :
  1348.          {  begin
  1349.           ScanForToken(commandLine, commandLen, value, oFILERECTYPE);
  1350.           TestAndSetValue(value, fileEOL, token, commandType);
  1351.       end } ;
  1352.      oLOCALECHO :
  1353.       BEGIN
  1354.         ScanForToken(commandLine, commandLen, value, oLOCECHOTYPE);
  1355.         TestAndSetValue(value, localEcho, token, commandType);
  1356.       END;
  1357.      oEIGHTBIT:
  1358.       BEGIN
  1359.         ScanForToken(commandLine, commandLen, value, oEIGHTBITTYPE);
  1360.         TestAndSetValue(value, eightBitQuoting, token, commandType);
  1361.       END;
  1362.      oPARITY :
  1363.       BEGIN
  1364.         ScanForToken(commandLine, commandLen, value, oPARITYTYPE);
  1365.         TestAndSetValue(value, parity, token, commandType);
  1366.       END;
  1367.      oSPEED,
  1368.      oLINE,
  1369.      oESCAPE :
  1370.      PrintMessage(NOTIMPLEMENTED);
  1371.      oDELAY :
  1372.       BEGIN
  1373.         ScanForValue(commandLine, commandLen, value,
  1374.              DECIMAL, commandType);
  1375.         TestAndSetValue(value, delay, token, commandType);
  1376.       END;
  1377.      oQUESTIONM :
  1378.      IF (commandType = oSETTYPE)
  1379.       THEN
  1380.       PrintSetHelp
  1381.       ELSE
  1382.       PrintShowHelp;
  1383.      oALL :
  1384.      IF (commandType = oSHOWTYPE)
  1385.       THEN
  1386.       PrintAllParameters
  1387.       ELSE
  1388.       PrintMessage(INVALIDSETCOMMAND);
  1389.      ELSE
  1390.      IF (commandType = oSETTYPE)
  1391.       THEN
  1392.       PrintMessage(INVALIDSETCOMMAND)
  1393.       ELSE
  1394.       PrintAllParameters;
  1395.     END;
  1396.      END;
  1397.  
  1398.  
  1399.     {  Routine to Parse the incoming line for a valid command. }
  1400.     PROCEDURE ParseInput(VAR commandLine : string80;
  1401.              VAR commandLen : integer;
  1402.              VAR runType : command);
  1403.  
  1404.  
  1405.     VAR
  1406.       token : integer;
  1407.  
  1408.      BEGIN
  1409.        ScanForToken(commandLine, commandLen, token, oMAINTYPE);
  1410.  
  1411.        CASE token OF
  1412.      oSET       : ParseSetShowCommand(commandLine, commandLen, oSETTYPE);
  1413.      oSHOW      : ParseSetShowCommand(commandLine, commandLen, oSHOWTYPE);
  1414.      oSEND,
  1415.      oRECEIVE  :
  1416.       BEGIN
  1417.         ParseSendReceiveCommand(commandLine, commandLen,token);
  1418.         IF ((token = oSEND) AND (sFileSpec = oON))
  1419.          THEN
  1420.          runType := Transmit
  1421.          ELSE
  1422.          IF (token <> oSEND)
  1423.           THEN
  1424.           runType := Receive;
  1425.       END;
  1426.      oSTATUS    : PrintStatus;
  1427.      oCONNECT   : runType := Connect;
  1428.      oHELP      : PrintHelpFile;
  1429.      oQUESTIONM : PrintMainHelp;
  1430.      oEXIT,
  1431.      oQUIT     : exitProgram := true;
  1432.      ELSE
  1433.      PrintMessage(INVALIDCOMMAND);
  1434.     END;
  1435.      END;
  1436.  
  1437.  
  1438.     {  Routine to print command line prompt and get user input }
  1439.     FUNCTION CommandPrompt(VAR commandLine : string80;
  1440.                VAR commandLen : integer) : boolean;
  1441.  
  1442.  
  1443.     VAR
  1444.       noInput : boolean;
  1445.  
  1446.      BEGIN
  1447.        noInput := true;
  1448.        WHILE (noInput) DO
  1449.     BEGIN
  1450.       GTLINE(commandLine);
  1451.       commandLen := LenString(commandLine);
  1452.  
  1453.       IF (commandLen > 0)
  1454.        THEN
  1455.         BEGIN
  1456.           noInput := false;
  1457.           StrUpcase(commandLine, commandLen);
  1458.         END
  1459.     END;
  1460.  
  1461.        CommandPrompt := NOT(noInput);
  1462.      END;
  1463.  
  1464.     { Start of main procedure }
  1465.  
  1466.    BEGIN
  1467.  
  1468.      WHILE ( NOT(exitProgram) AND
  1469.         NOT((RunType = Receive) OR
  1470.         (RunType = Transmit) OR
  1471.         (RunType = Connect)) ) DO
  1472.       BEGIN
  1473.     IF CommandPrompt(commandLine, commandLen)
  1474.      THEN
  1475.      ParseInput(commandLine, commandLen, RunType)
  1476.      ELSE
  1477.      exitProgram := true;
  1478.       END;
  1479.  
  1480.  
  1481.      {  Set parms that could not be set normally }
  1482.  
  1483.      {   if (fileEol = oLF) then
  1484.       EOLFORFILE := LineFeed
  1485.       else if (fileEol = oCLF) then
  1486.       EOLFORFILE := CrLf
  1487.       else
  1488.       EOLFORFILE := JustCr;
  1489.       }
  1490.  
  1491.      IF (fileWarn = oOFF)
  1492.       THEN
  1493.       fileWarning := false
  1494.       ELSE
  1495.       fileWarning := true;
  1496.  
  1497.      IF (eightBitQuoting = oOFF)
  1498.       THEN
  1499.       Def8QuoteMode := TYPEY
  1500.       ELSE
  1501.       Def8QuoteMode := AMPER;
  1502.  
  1503.      SetEchoAndParity;
  1504.  
  1505.    END;
  1506.