$DEBUG PAGELENGTH(55)

/***********************/
/*                     */
/*  G E T $ F N A M E  */
/*                     */
/***********************/

M$GET$FNAME: DO;
$NOLIST
$INCLUDE (COMMON.DCL)
$INCLUDE (ISIS.DCL)
$INCLUDE (:F1:ISISIO.DCL)
$INCLUDE (STRING.DCL)
$LIST
/****************************************************/
/*                                                  */
/*  PROCEDURE NAME - GET$FNAME                      */
/*                                                  */
/*  FUNCTION - READ FILE NAME FROM CONSOL,          */
/*              AVOIDING ERRORS AS POSSIBLE         */
/*              ACCORDING TO INPUT PARAMETERS.      */
/*             AFTER THE FIRST CHARACTER OF A NAME  */
/*              IS ENTERED, THE REMAINING 13        */
/*              CAHARCTERS ARE BLANKED OUT ON       */
/*              SCREEN, IN ORDER TO ERASE ANY       */
/*              UNDERLINE ETC. PREVIOUSLY PRINTED.  */
/*             A CHARACTER IS EXCEPTED ONLY IF IT   */
/*              IS VALID. ELSE, A BEEP IS RETURNED. */
/*             FILE NAME IS TERMINATED BY A CR. THE */
/*              CR IS NOT ECHOED TO SCREEN, AND THE */
/*              CURSOR IS RETRURNED TO THE FIRST    */
/*              CHRARACTER OF THE NAME.             */
/*                                                  */
/*  INPUT - NAME$P : ADDRESS, A POINTER TO A STRING */
/*             VARIABLE WHICH WILL RETURN THE NAME  */
/*             OF THE FILE. THE VARIABLE MUST HAVE  */
/*             A LENGTH OF 14, AND IT IS INITALIZED */
/*             BY THE PROCEDURE.                    */
/*          TYPE : BYTE, THE TYPE OF THE FILE -     */
/*             0 - ANY FILE                         */
/*             1 - DISK FILE ONLY                   */
/*             2 - DISK FILE OR INPUT DEVICE        */
/*             3 - DISK FILE OR OUTPUT DEVICE       */
/*          WILDCARD : BOOLEAN, ENABLES WILDCARD    */
/*             FILE NAME TO BE USED.                */
/*          NULLNAME : BOOLEAN, ENABLES A NULL NAME */
/*             TO BE RETURNED.                      */
/*          EXTPNT : BOOLEAN, ENABLES A NULL        */
/*             EXTENSION TO BE ENTERED AFTER A      */
/*             POINT.                               */
/*                                                  */
/*  OUTPUT - FILE NAME, AS POINTED BY NAME$P        */
/*                                                  */
/*  LAST UPDATED - 30.5.82  DROR                    */
/*                                                  */
/****************************************************/



GETFNAME: PROCEDURE(NAME$P,TYPE,WILDCARD,NULLNAME,EXTPNT) PUBLIC;
   DECLARE
      NAME$P ADDRESS,
      TYPE BYTE,
      WILDCARD BOOLEAN,
      NULLNAME BOOLEAN,
      EXTPNT BOOLEAN;
   DECLARE
      (NAME BASED NAME$P) STRING;
   DECLARE
      STATE BYTE,             /* LOGIC STATE OF PROGRAM */
      (LAST5,LAST7) BOOLEAN,  /* DENOTES LAST SUB-STATE OF STATE 5 OR 7 */
      (LEN5,LEN7) BYTE,       /* # OF CHARACTERS ENTERED IN STATE 5 OR 7 */
      I BYTE,                 /* GENERAL-PURPOSE COUNTER */
      CHAR BYTE,              /* TEMPORARY CHARACTER */
      DISK BOOLEAN;           /* DENOTES A DISK FILE NAME HAS BEEN ENTERD */
   DECLARE
      DELETE(*) BYTE DATA(    /* CHARACTER DELETE CODE */
         BS,' ',BS,
         0),
      CLR$NAME(*) BYTE DATA(  /* CLEAR FILE NAME FROM SCREAN */
         '             ',
         BS,BS,BS,BS,
         BS,BS,BS,BS,
         BS,BS,BS,BS,
         BS,
         0);

   /****************************************/
   /*                                      */
   /*  ADD :  ADDS CHAR TO FILENAME, AND   */
   /*          ECHOS IT ON SCREEN          */
   /*                                      */
   /****************************************/

   ADD: PROCEDURE(CHAR);
      DECLARE 
         CHAR BYTE;
      NAME.D(NAME.L)=CHAR;
      NAME.L=NAME.L+1;
      CALL CO(CHAR);
   END ADD;

   /****************************************/
   /*                                      */
   /*  RUB :  DELETE ONE CHARACTER FROM    */
   /*          FILENAME AND FROM SCREEN    */
   /*                                      */
   /****************************************/
   
   RUB: PROCEDURE;
      NAME.L=NAME.L-1;
      CALL MSG$OUT(.DELETE);
   END RUB;

   /****************************************/
   /*                                      */
   /*  CMP$DEVICE :                        */
   /*    COMPARE DEVICE NAME TO VALID      */
   /*    NAMES, ACORDING TO 'TYPE'.        */
   /*  INPUT - CHAR0, CHAR1 : BYTE, THE    */
   /*           TWO CHARACTERS OF THE      */
   /*           DEVICE NAME.               */
   /*          NUM : BYTE, NUMBER OF VALID */
   /*           CHARACTERS IN THE DEVICE   */
   /*           NAME. MUST BE 1 OR 2. IF   */
   /*           1, THEN CHAR0 IS THE VALID */
   /*           CHARACTER.                 */
   /*  OUTPUT - BOOLEAN, TRUE IF A VALID   */
   /*            NAME.                     */
   /*                                      */
   /****************************************/
   
   CMP$DEVICE: PROCEDURE(CHAR0,CHAR1,NUM) BOOLEAN;
      DECLARE
         CHAR0 BYTE,
         CHAR1 BYTE,
         NUM BYTE;
      DECLARE
         FOUND BOOLEAN,
         I BYTE;
      DECLARE
         DEVICES STRUCTURE(
            INP(18) BYTE,
            OUT(22) BYTE
            ) DATA (
               'TI','TR','VI','HR','CI','BB','R1','R2','I1',
               'TO','TP','VO','HP','LP','CO','BB','P1','P2','L1','O1'
               );

      FOUND=FALSE;
      IF (TYPE=0) OR (TYPE=2)
         THEN DO;
            I=0;
            DO WHILE (FOUND=FALSE) AND (I < LENGTH(DEVICES.INP)-1);
               IF DEVICES.INP(I)=UPPER(CHAR0)
                  THEN IF NUM=1
                     THEN FOUND=TRUE;
                     ELSE IF DEVICES.INP(I+1)=UPPER(CHAR1)
                        THEN DO;
                           FOUND=TRUE;
                           DISK=FALSE;
                        END;
               I=I+2;
            END;
      END;
      IF NOT(FOUND) AND ((TYPE=0) OR (TYPE=3))
         THEN DO;
            I=0;
            DO WHILE (FOUND=FALSE) AND (I < LENGTH(DEVICES.OUT)-1);
               IF DEVICES.OUT(I)=UPPER(CHAR0)
                  THEN IF NUM=1
                     THEN FOUND=TRUE;
                     ELSE IF DEVICES.OUT(I+1)=UPPER(CHAR1)
                        THEN DO;
                           FOUND=TRUE;
                           DISK=FALSE;
                        END;
               I=I+2;
            END;
      END;
      IF NOT(FOUND)
         THEN DO;
            IF UPPER(CHAR0)='F'
               THEN IF NUM=1
                  THEN FOUND=TRUE;
                  ELSE IF (CHAR1 >= '0') AND (CHAR1 <= '9')
                     THEN FOUND=TRUE;
            IF FOUND AND (NUM=2)
               THEN DISK=TRUE;
         END;

      RETURN (FOUND);
   END CMP$DEVICE;

   /*** START OF GET$FNAME ***/
   
   NAME.ML=14;
   NAME.L=0;
   STATE=0;
   LEN5,LEN7=0;
   LAST5,LAST7=FALSE;
   DO WHILE STATE < 8;
      CHAR=CI;
      DO CASE(STATE);

         /*** STATE 0 - NO CHARACTERS HAVE BEEN ENTERED YET ***/
         
         S0: DO;
           IF CHAR=':'
              THEN DO;
                 CALL ADD(CHAR);
                 CALL MSG$OUT(.CLR$NAME);
                 STATE=1;
              END;
           ELSE IF (CHAR=CR) AND NULLNAME
              THEN STATE=0FFH;
           ELSE IF ALPHA(CHAR,WILDCARD)
              THEN DO;
                 CALL ADD(CHAR);
                 CALL MSG$OUT(.CLR$NAME);
                 STATE=5;
                 LEN5=1;
                 IF (CHAR='*') AND WILDCARD
                    THEN LAST5=TRUE;
                    ELSE LAST5=FALSE;
              END;
           ELSE CALL CO(BELL);
         END S0;

         /*** STATE 1 - A ':' HAS BEEN ENTERED ***/
         /***  GET FIRST CHAR OF DEVICE NAME   ***/

         S1: DO;
            IF CHAR=RUBOUT
               THEN DO;
                  CALL RUB;
                  STATE=0;
               END;
            ELSE IF CMP$DEVICE(CHAR,0,1)
               THEN DO;
                  CALL ADD(CHAR);
                  STATE=2;
               END;
            ELSE CALL CO(BELL);
         END S1;

         /*** STATE 2 - GET SECOND CHAR OF DEVICE NAME ***/

         S2: DO;
            IF CHAR=RUBOUT
               THEN DO;
                  CALL RUB;
                  STATE=1;
               END;
            ELSE IF CMP$DEVICE(NAME.D(1),CHAR,2)
               THEN DO;
                  CALL ADD(CHAR);
                  STATE=3;
               END;
            ELSE CALL CO(BELL);
         END S2;

         /*** STATE 3 - DEVICE NAME HAS BEEN ENTERED ***/
         /***  GET A ':'                             ***/

         S3: DO;
            IF CHAR=RUBOUT
               THEN DO;
                  CALL RUB;
                  STATE=2;
               END;
            ELSE IF CHAR=':'
               THEN DO;
                  CALL ADD(CHAR);
                  STATE=4;
               END;
            ELSE CALL CO(BELL);
         END S3;

         /*** STATE 4 - GET FIRST CHAR AFTER ':device:' ***/
         
         S4: DO;
            IF CHAR=RUBOUT
               THEN DO;
                  CALL RUB;
                  STATE=3;
               END;
            ELSE IF ((CHAR=CR) AND ((NOT DISK) OR ((TYPE=3) AND WILDCARD)))
               THEN STATE=0FFH;
            ELSE IF ALPHA(CHAR,WILDCARD) AND DISK
               THEN DO;
                  CALL ADD(CHAR);
                  STATE=5;
                  LEN5=1;
                  IF CHAR='*'
                     THEN LAST5=TRUE;
                     ELSE LAST5=FALSE;
               END;
            ELSE CALL CO(BELL);
         END S4;

         /*** STATE 5 - GET UP TO 6 CHARACTERS OF FILE NAME ***/
         
         S5: DO;
            IF CHAR=RUBOUT
               THEN DO;
                  CALL RUB;
                  LEN5=LEN5-1;
                  LAST5=FALSE;
                  IF LEN5=0
                     THEN IF NAME.L=0
                        THEN STATE=0;
                        ELSE STATE=4;
               END;
            ELSE IF CHAR=CR
               THEN STATE=0FFH;
            ELSE IF CHAR='.'
               THEN DO;
                  CALL ADD(CHAR);
                  STATE=6;
               END;
            ELSE IF (LEN5 < 6) AND (NOT LAST5) AND ALPHA(CHAR,WILDCARD)
               THEN DO;
                  CALL ADD(CHAR);
                  LEN5=LEN5+1;
                  IF CHAR='*'
                     THEN LAST5=TRUE;
               END;
            ELSE CALL CO(BELL);
         END S5;

         /*** STATE 6 - FILE NAME HAS BEEN ENTERD ***/
         /***  GET A '.'                          ***/

         S6: DO;
            IF CHAR=RUBOUT
               THEN DO;
                  CALL RUB;
                  STATE=5;
               END;
            ELSE IF (CHAR=CR) AND EXTPNT
               THEN STATE=0FFH;
            ELSE IF ALPHA(CHAR,WILDCARD)
               THEN DO;
                  CALL ADD(CHAR);

                  STATE=7;
                  LEN7=1;
                  IF CHAR='*'
                     THEN LAST7=TRUE;
                     ELSE LAST7=FALSE;
               END;
            ELSE CALL CO(BELL);
         END S6;

         /*** STATE 7 - GET UP TO 3 CHARACTERS OF EXTENSION ***/
         
         S7: DO;
            IF CHAR=RUBOUT
               THEN DO;
                  CALL RUB;
                  LEN7=LEN7-1;
                  LAST7=FALSE;
                  IF LEN7=0
                     THEN STATE=6;
               END;
            ELSE IF CHAR=CR
               THEN STATE=0FFH;
            ELSE IF (LEN7 < 3) AND (NOT LAST7) AND ALPHA(CHAR,WILDCARD)
               THEN DO;
                  CALL ADD(CHAR);
                  LEN7=LEN7+1;
                  IF CHAR='*'
                     THEN LAST7=TRUE;
               END;
            ELSE CALL CO(BELL);
         END S7;

      END;   /* DO CASE */
   END;  /* DO WHILE */

   DO I=1 TO NAME.L;
      CALL CO(BS);
   END;
   NAME.D(NAME.L)=0;

END GET$FNAME;

END M$GET$FNAME;