$DEBUG PAGELENGTH(55)

/*********************/
/*                   */
/*  G E T $ P A R M  */
/*                   */
/*********************/

M$GET$PARM: DO;
$NOLIST
$INCLUDE (COMMON.DCL)
$INCLUDE (ISIS.DCL)
$INCLUDE (:F1:ISISIO.DCL)
$INCLUDE (STRING.DCL)
$LIST
/****************************************************/
/*                                                  */
/*  PROCEDURE PARM - GET$PARM                       */
/*                                                  */
/*  FUNCTION - READ A PARAMTER FROM CONSOL,         */
/*              AVOIDING ERRORS AS POSSIBLE         */
/*              ACCORDING TO INPUT PARAMETERS.      */
/*             AFTER THE FIRST CHARACTER            */
/*              IS ENTERED, THE REMAINING           */
/*              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. */
/*             PARAMETER IS TERMINATED BY A CR. THE */
/*              CR IS NOT ECHOED TO SCREEN, AND THE */
/*              CURSOR IS RETRURNED TO THE FIRST    */
/*              CHRARACTER OF THE PARM.             */
/*                                                  */
/*  INPUT - PARM$P : ADDRESS, A POINTER TO A STRING */
/*             VARIABLE WHICH WILL RETURN THE       */
/*             PARAMETER.                           */
/*          ALL : BOOLEAN, ENABLES NON-ALPHA        */
/*             CHARACTERS TO BE ENTERED.            */
/*                                                  */
/*  OUTPUT - PARAMETER, AS POINTED BY PARM$P        */
/*                                                  */
/*  LAST UPDATED - 24.5.82  DROR                    */
/*                                                  */
/****************************************************/



GET$PARM: PROCEDURE(PARM$P,ALL) PUBLIC;
   DECLARE
      PARM$P ADDRESS,
      ALL BOOLEAN;
   DECLARE
      (PARM BASED PARM$P) STRING;
   DECLARE
      I BYTE,
      CHAR BYTE;
   DECLARE
      DELETE(*) BYTE DATA(
         BS,' ',BS,
         0);

   PARM.L=0;
   CHAR=CI;
   DO I=1 TO PARM.ML;
      CALL CO(' ');
   END;
   DO I=1 TO PARM.ML;
      CALL CO(BS);
   END;
   DO WHILE (CHAR<>CR) AND (PARM.L<PARM.ML);
      IF CHAR=RUBOUT AND PARM.L>0
         THEN DO;
            CALL MSG$OUT(.DELETE);
            PARM.L=PARM.L-1;
         END;
      ELSE IF (ALL AND (CHAR>=' ') AND (CHAR<='~'))
                  OR ((NOT ALL) AND ALPHA(CHAR,FALSE))
         THEN DO;
            CALL CO(CHAR);
            PARM.D(PARM.L)=CHAR;
            PARM.L=PARM.L+1;
         END;
      ELSE CALL CO(BELL);
      CHAR=CI;
   END;
   PARM.D(PARM.L)=0;
   DO I=1 TO PARM.L;
      CALL CO(BS);
   END;
   END GET$PARM;

END M$GET$PARM;