*DECK SSRRCS PROC SSRRCS(CST, CSTRING, (LEN), OUTPARM, (MAX), OUTCNT, EC, ET); # TITLE SSRRCS - RECOGNIZE COMMAND STRING. # BEGIN # SSRRCS # # ** SSRRCS - RECOGNIZE COMMAND STRING. * * A. LIM. 82/02/17. * * THIS PROCEDURE-S MAIN FUNCTION IS TO RECOGNIZE AN INPUT COMMAND * STRING *CSTRING* (OPERATOR TYPEINS), GIVEN THE LENGTH *LEN* OF * THE STRING, AND THE COMMAND-SYNTAX/SEMANTIC-TABLE *CST* THAT * THIS STRING IS GOING TO CHECK AGAINST. * IF THE STRING PASS BOTH THE SYNTAX AND SEMANTIC CHECKING, * ON RETURNING TO THE CALLER, *OUTPARM* CONTAINS THE OUTPUT- * PARAMETER-LIST RESULTING FROM THE CHECKINGS, AND *OUTCNT* * REFLECTS THE COUNT OF NUMBER OF ENTRIES IN *OUTPARM*. * ELSE, IF THE STRING FAIL IN EITHER CHECKING, AN ERROR * CODE IN *EC* OR WITH ERROR TEXT IN *ET* WILL BE RETURNED. * THIS PROCEDURE IS CALLED INTO EXECUTION BY: * *CSSROC* *NVFOROC* * * PROC SSRRCS(CST, CSTRING, (LEN), OUTPARM, (MAX), OUTCNT, EC, ET) * * ENTRY CST = COMMAND SYNTAX/SEMANTIC TABLE THE CURRENT * INPUT STRING IS GOING TO CHECK AGAINST. * EACH COMMAND SYNTAX LINE IS TERMINATED BY AN * END-OF-LINE (EOL$) TERMINATOR, AND THE TABLE * IS TERMINATED BY A LAST ENTRY CONTAINING ONLY * THE EOL$ AS THE FIRST CHARACTER. * CSTRING = COMMAND STRING TO BE RECOGNIZED. * LEN = LENGTH IN CHARACTERS OF COMMAND STRING. * OUTPARM = ADDRESS OF OUTPUT-PARAMETER-LIST. * MAX = MAX NO. OF ENTRIES ALLOWABLE IN OUTPARM. * * EXIT CST = UNCHANGED. * CSTRING = UNCHANGED. * LEN = UNCHANGED. * OUTPARM = OUTPUT-PARAMETER-LIST. * (MEANINGLESS IF EC NQ 0) * MAX = UNCHANGED. * OUTCNT = COUNT OF ACTUAL NO. OF ENTRIES IN OUTPARM. * (MEANINGLESS IF EC NQ 0) * EC = ERROR CODE: * 0 = NO ERROR. * 1 = PARAMETER TOO LONG. * 2 = EXPECTING PERIOD. * 3 = EXPECTING PERIOD OR COMMA. * 4 = UNRECOGNIZED COMMAND. * 5 = INVALID COMBINATION OF PARAMETERS. * 6 = COMMAND MISSING PARAMETER. * 7 = OUTPUT PARAMETER LIST TOO SHORT. * 8 = INPUT MESSAGE TOO LONG. * ET = ERROR TEXT(UP TO 10 CHARACTERS), CONTAINS THAT * PART OF THE COMMAND STRING THAT IS IN ERROR. * * NOTE THIS PROCEDURE MIGHT END UP IN AN INFINITE LOOP, OR * RESULT MIGHT BE UNPREDICTABLE IF CST WERE NOT BUILT * CORRECTLY. * * METHOD: * * THE COMMAND SYNTAX TABLE *CST* IS INPUT TO THE COMMAND * RECOGNIZER TO DEFINE THE SYNTAX AND THE SEMANTICS OF * THE ALLOWABLE COMMANDS. * * THE TABLE IS ORDERED(SCANNED TOP TO BOTTOM) AND CONTAINS * FLAG CHARACTERS TO DEFINE THE ORDER AND MEANING OF THE * CHARACTERS TO BE ENTERED TO SELECT THE ACTION TO BE PERFORMED. * THE TABLE IS DESIGNED TO BE BOTH HUMAN AND COMPUTER READABLE, * AND CONCISE. INFORMATION ABOUT AN INDIVIDUAL COMMAND IS TO BE * COLLECTED TOGETHER. * * THE SYNTAX TABLE CONTAINS THE SEMANTIC TABLE WITHIN IT. DURING * THE SYNTAX SCAN, THE SEMANTICS (AND THEIR FLAG CHARACTERS) ARE * IGNORED. DURING THE SEMANTIC SCAN, MOST OF THE SYNTAX TABLE IS * IGNORED AND THE SEMANTIC FLAG CHARACTERS ARE USED FOR FURTHER * CHECKING OF PROPERNESS OF THE INPUT LINE. SOME CHARACTERS ARE * USED DURING BOTH SCANS, THUS THE REASON TO MERGE THE TWO TABLES * AND KEEP THE INFORMATION ABOUT A COMMAND TOGETHER. * * DURING THE COMMAND RECOGNIZING PROCESS, BOTH THE INPUT LINE AND * THE CURRENT LINE OF SYNTAX ARE BROKEN INTO TOKENS FOR COMPARISION. * THIS BREAKING UP INTO TOKENS TAKES PLACE WHENEVER A TOKEN IS * REQUIRED. * * STARTING WITH THE FIRST TOKEN OF THE FIRST LINE OF SYNTAX, THE * SYNTAX TOKEN IS EXAMINED FOR ACTION TO PERFORM SUCH AS COMPARING * THE TOKEN WITH THE NEXT INPUT TOKEN, STORING A PARAMETER CODE * IN THE OUTPUT PARAMETER LIST, OR OTHER ACTION. * * AS TOKENS ARE READ FROM SYNTAX, POSSIBILITIES ARE CHECKED FOR * MATCHING WITH WHAT WAS TYPED IN. AS LONG AS WHAT WAS TYPED IN * IS ALLOWABLE WITHIN THE CURRENT SYNTAX LINE, THE PROCESS * CONTINUES TO THE END OF THE INPUT LINE. IF AT ANY POINT AN * INPUT TOKEN IS NOT PERMITTED ACCORDING TO THE SYNTAX LINE, ALL * INFORMATION THAT MAY HAVE BEEN DETERMINED UP TO THIS POINT IS * DISCARDED AND A FRESH START IS MADE USING THE NEXT SYNTAX LINE. * WHEN THE LAST SYNTAX LINE DID NOT MATCH, THE TYPE-IN IS DECLARED * INVALID AND REJECTED AS UNRECOGNIZED. WHEN THE END OF THE INPUT * LINE IS REACHED AND THE SYNTAX HAS PASSED ALL TESTS THEN A * SEMANTIC PASS IS DONE USING THE OUTPUT PARAMETER LIST AND THE * SYNTAX LINE THAT WAS JUST USED TO PASS THE INPUT LINE. AT THIS * TIME ANY DUPLICATE KEYWORDS, MISSING PARAMETERS AND DEFAULTS TO * BE INSERTED ARE RECOGNIZED AND ADDED TO THE OUTPUT OR THE ENTIRE * COMMAND REJECTED IF WHAT WAS ENTERED WAS INCORRECT. * * SYNTAX FLAG CHARACTERS: * * = ANY OF THE CHARACTER STRINGS A, B, C....Z * CAN MATCH AND ARE SYNONYMS. "_" CANNOT BE * IN STRING * * [ = RESYNC POINT. IF MISMATCH OCCURS, SKIP AND TRY * THE MATCH AT NEXT "[". * * @ = OUTPUT PARAMETER CODE * * ^ = END MATHCER. PERIOD OR COMMA OR END OF INPUT LINE * CAN MATCH AND TERMINATE SCAN. COMMA CAN MATCHING * SYNTAX SCAN TO FIRST "[" IF PRESENT. * * ? = PARAMETER, 1 TO 7 ALPHA-NUMERIC CHARACTERS. * COUPLED WITH LAST OUTPUT PARAMETER CODE. * * & = CHARACTER STRING, 50 CHARACTERS MAXIMUM TO END * OF THE LINE. ALSO TERMINATES SYNTAX SCAN. * * $ = END OF LINE TERMINATOR. * IF WERE THE ONLY CHARACTER IN A SYNTAX LINE, * THEN IT IS AN END OF TABLE INDICATOR. * * THE FIRST RESYNC POINT "[" HAS SPECIAL SIGNIFICANCE IN THAT IT IS * THE POINT THE SYNTAX SCAN IS SET TO UPON MATCHING A COMMA, "^" * IN THE SYNTAX WITH A "," IN THE INPUT LINE. IF A MISMATCH OCCURS * WITH THE INPUT TOKEN THEN THE SYNTAX SCAN IS ADVANCED TO THE NEXT * "[" AND ANOTHER COMPARISON IS MADE. WHEN NO MORE "[" POINTS * REMAIN IN THE SYNTAX THEN A MISMATCH IS DECLARED, THE OUTPUT * PARAMETER LIST IS DISCARDED, AND INPUT SCAN RESET TO THE BEGINNING * OF THE INPUT LINE AND THE NEXT SYNTAX LINE IS TRIED. * * THE OUTPUT PARAMETER CODE "@" WHEN READ FROM SYNTAX RESULTS IN A * NEW OUTPUT PARAMETER WORD TO BE ADDED AND THE NEXT THREE CHARACTERS * FROM THE SYNTAX TABLE TO BE INSERTED INTO THE WORD. SHOULD A "?" * BE READ FROM THE SYNTAX LINE, THEN THE NEXT TOKEN FROM INPUT IS * STORED INTO THE OUTPUT PARAMETER WORD WITH THE LAST PARAMETER CODE. * * * SEMANTIC FLAG CHARACTERS: * * \ = SET, ONLY ONE OF SET ALLOWED. * * ! = DEFAULT, ONLY ALLOWABLE WITHIN SET. INCLUDE * IF NO OTHER MEMBER OF SET INCLUDED. * * * A SET IN TERMS OF SEMANTICS IS THE LIST OF PARAMETER CODES (3 * CHARACTERS FOLLOWING "@") CONTAINED WITHIN PAIRS OF "\" * CHARACTERS. * * ONLY ONE MEMBER OF A SET MAY BE PRESENT IN THE OUTPUT PARAMETER * LIST, AND THIS ALSO DISALLOWS REPEATED OCCURRENCES OF THE SAME * KEYWORD. * * IF THE CHARACTER "!" APPEARS WITHIN A SET, THEN ONE AND ONLY ONE * PARAMETER CODE FROM THE SET MUST BE IN THE OUTPUT PARAMETER LIST. * IF THE "!" CHARACTER IS FOLLOWED IMMEDIATELY BY THE "@" CHARACTER, * THEN THE 3 CHARACTERS FOLLOWING THE "@" ARE THE DEFAULT AND WILL * BE INSERTED INTO THE PARAMETER LIST IF NO OTHER MEMBER OF THE SET * WAS IN THE INPUT. IF THE "!" CHARACTER IN THE SYNTAX WAS FOLLOWED * BY A CHARACTER OTHER THAN "@" THEN AN ERROR IS DECLARED IF NO * MEMBER OF THE SET WAS IN THE INPUT. * * * SEMANTIC EXAMPLES: * * \![ \ = AT LEAST ONE PARAMETER MUST BE ENTERED AND * THERE IS NO DEFAULT. * * \ \ = THE ENTIRE SET OF PARAMETERS IS OPTIONAL. * * \ !@DEF\ = DEFAULT, I.E. IF NO MEMBER OF SET IS ENTERED, * THE PARAMETER CODE FOLLOWING THE "!@" CHARACTERS * IS THE DEFAULT FOR THE SET. * # # **** PROC SSRRCS XREF LIST. # XREF BEGIN PROC SSBEBF; # EXTRACT BIT FIELD FROM A TABLE # PROC SSBSBF; # STORE BIT FIELD INTO A TABLE # PROC SSRGNT; # GET NEXT TOKEN FROM A COMMAND STRING # END # **** # # DEFS FOR ERROR CODE # DEF NOERR$ # 0 #; # NO ERROR # DEF PRMLNG$ # 1 #; # PARAMETER TOO LONG # DEF EXPRD$ # 2 #; # EXPECTING PERIOD # DEF EXPDCMA$ # 3 #; # EXPECTING PERIOD OR COMMA # DEF UNRGCMD$ # 4 #; # UNRECOGNIZED COMMAND # DEF INVCMPRM$ # 5 #; # INVALID COMBINATION OF PARAMETERS # DEF CMDMSGPRM$ # 6 #; # COMMAND MISSING PARAMETER # DEF OUTPMSH$ # 7 #; # OUTPUT PARAMETER LIST TOO SHORT # DEF MSGLNG$ # 8 #; # INPUT MESSAGE TOO LONG # DEF VALOUT$ # 9 #; # VALUE OUT-OF-RANGE # # DEFS FOR SYNTAX, SEMANTIC AND INPUT FLAG CHARACTERS, AND OUTPUT # # PARAMETER LIST CODE. # DEF MESSAGE$ # "&" #; # SYNTAX- CHAR STRING, 50 OR LESS CHARS # DEF PRMCODE$ # "@" #; # SYNTAX- OUTPUT PARAMETER CODE # DEF CHARLEN$ # 6 #; # CHAR LENGTH IN BITS FOR OCT DISP-CODE # DEF CHARWD$ # 10 #; # NO. OF 6-BIT CHAR PER CM WORD # DEF COMMA$ # "," #; # SYNTAX AND SEMANTIC- SEPARATOR # DEF A$ # "A" #; # INPUT- LOWER BOUND FOR ALPH-NUM STRING# DEF EOL$ # "$" #; # SYNTAX- END OF LINE TERMINATOR # DEF DFONEST$ # "!" #; # SEMANTIC- DEFAULT, ONE OF SET # DEF ONESET$ # "\" #; # SEMANTIC- SET, ONE OF SET ALLOWED # DEF ENDSYNST$ # ">" #; # SYNTAX- END OF SYNONYM SET # DEF MAXMSGL$ # 50 #; # INPUT- MAX MESSAGE LENGTH IN CHARS # DEF MAXSVC # 255 #; # INPUT- MAX NUMBER OF SVC CIRCUITS # DEF ZERO$ # "0" #; # INPUT- LOWER BOUND FOR NUMERIC STRING # DEF NINE$ # "9" #; # INPUT- UPPER BOUND OF ALPH-NUM STRING # DEF PERIOD$ # "." #; # SEMANTIC- END OF INPUT TERMINATOR # DEF ENDMH$ # "^" #; # SYNTAX- END MATCHER # DEF PRMTR$ # "?" #; # SYNTAX- PARAMETER 1-7 ALPHA-NUM CHARS # DEF RESYNC$ # "[" #; # SYNTAX- RESYNC CHAR # DEF BEGSYNST$ # "<" #; # SYNTAX- BEGIN OF SYNONYM SET # DEF SYNSPTR$ # "_" #; # SYNTAX- SEPARATOR FOR SYNONYM SET # DEF VEB$ # "VEB" #; # OUTPUT-PARAMETER-LIST VERB CODE # DEF RPARENTH # "(" # ; DEF LPARENTH # ")" # ; DEF MS0$ # "MS0" #; # PARAMETER CODE FOR SEND MESSAGE CMD # # DEFS FOR ARRAY SIZES # DEF CSTSIZ$ # 31 #; # CST SIZE = 30 ENTRY + 1 TERMINATE ENTR# DEF CSSIZ$ # 14 #; # CMD STRING SZ= 139 + 1 TERMINATE CHAR # # FORMAL PARAMETERS # # ** CST - COMMAND SYNTAX/SEMANTIC TABLE * * THIS TABLE DEFINES THE SYNTAX AND SEMANTICS OF THE ALLOWABLE * COMMANDS. IT IS THIS TABLE THAT THE INPUT STRING IS GOING TO * CHECK AGAINST FOR VALID COMMAND. # ARRAY CST[00:CSTSIZ$] S(CSSIZ$); BEGIN ITEM CST$LINE C(00,00,140); END # ** CSTRING - COMMAND STRING. * * A COMMAND STRING OF *LEN* NUMBER OF CHARACTERS. # ARRAY CSTRING[00:00] S(CSSIZ$); BEGIN ITEM CS$STRING C(00,00,140); END ITEM LEN I; # LENGTH IN CHARS OF COMMAND STRING # # ** OUTPARM - OUTPUT PARAMETER LIST. * * THIS ARRAY CONTAINS THE OUTPUT PARAMETER LIST RESULTING FROM * A SUCCESSFUL RECOGNITION OF THE INPUT STRING. * NOTE: THIS ARRAY SIZE HAS TO BE THE SAME AS *MAX*. # ARRAY OUTPARM[00:30] S(1); BEGIN ITEM OPM$WORD C(00,00,10); # WHOLE WORD REFERENCE # ITEM OPM$VALUE C(00,00,07); # PARAMETER VALUE # ITEM OPM$MSGL U(00,00,42); # MESSAGE LENGTH # ITEM OPM$CODE C(00,42,03); # PARAMETER CODE # END ITEM MAX I; # MAX NO. OF ENTRIES IN OUTPARM # ITEM OUTCNT I; # ACTUAL NO. OF ENTRIES IN OUTPARM # ITEM EC I; # ERROR CODE # ITEM ET C(10); # ERROR TEXT # # ** PARMLST - PARAMETER LIST. * * THIS IS AN INTERMEDIATE PARAMETER LIST BUILT BY THE SYNTAX * CHECKER WITH PARAMETERS IN THE ORDER AS IT IS ENTERED IN * THE COMMAND. THEN IT IS USED BY THE SEMANTIC CHECKER TO * BUILD THE ACTUAL OUTPUT PARAMETER LIST(OUTPARM) WITH * PARAMETERS IN THE ORDER AS IT APPEARS IN THE COMMAND * SYNTAX TABLE. * NOTE: THIS ARRAY SIZE HAS TO BE THE SAME SIZE AS *OUTPARM*. # ARRAY PARMLST[00:30] S(1); BEGIN ITEM PML$WORD C(00,00,10); # WHOLE WORD REFERENCE # ITEM PML$VALUE C(00,00,07); # PARAMETER VALUE # ITEM PML$NCVAL U(00,00,08); # PARAMETER HEX VALUE # ITEM PML$MSGL U(00,00,42); # MESSAGE LENGTH # ITEM PML$CODE C(00,42,03); # PARAMETER CODE # END # ACTUAL PARAMETERS TO *SSBEBF*, *SSBSBF*, AND *SSRGNT* # ITEM BLEN I; # NO. OF BITS TO EXTRACT/STORE (X6) # ITEM GNTEC I; # ERROR CODE FROM *SSRGNT* # ITEM IBIT I; # INPUT- START BIT POSITION W/I WORD # ITEM IORD I; # INPUT- START WORD ORDINAL W/I TABLE # ITEM IPOS I; # INPUT- NEXT CHAR POSITION # ITEM IIPOS I; # INPUT- CURRENT CHAR POSITION # ITEM ITOKEN C(10); # INPUT- CURRENT TOKEN # ITEM PSPOS I; # SYNTAX- PREVIOUS CHAR POSITION # ITEM PSTOKEN C(10); # SYNTAX- PREVIOUS TOKEN # ITEM RESULT C(10); # RESULT OF EXTRACTION OF BIT FIELD # ITEM SBIT I; # SYNTAX_ START BIT POSITION W/I WORD # ITEM SORD I; # SYNTAX_ START WORD ORDINAL W/I TABLE # ITEM SPOS I; # SYNTAX- NEXT CHAR POSITION # ITEM STOKEN C(10); # SYNTAX- CURRENT TOKEN # # GENERAL ITEMS # ITEM CURLINE B; # LOOP EXIT VAR ON DONE WITH CURRENT LINE # ITEM DONE B; # LOOP EXIT VAR ON PUT MSG INTO OUTPARM # ITEM EOSET B; # LOOP EXIT VAR ON END OF SET # ITEM ERROR B; # LOOP EXIT VAR ON ERROR # ITEM FOUND B; # LOOP EXIT VAR ON FOUND CODE IN OUTPARM # ITEM FRSTEOS B; # FIRST END OF SET FOUND FLAG # ITEM I I; # INDUCTION VAR ON CST # ITEM J I; # INDUCTION VAR # ITEM K I; # INDUCTION VAR # ITEM L I; # INDUCTION VAR # ITEM M I; # INDUCTION VAR # ITEM N I; # INDUCTION VAR # ITEM MEMCNT I; # MEMBER COUNT # ITEM MEMREQD B; # MEMBER REQUIRED FLAG # ITEM MSGLEN I; # MESSAGE LENGTH IN CHARS # ITEM OP I; # INDEX TO OUTPARM # ITEM RESYNCFOUD B; # FIRST RESYNC FOUND FLAG # ITEM RESYNCPONT I; # FIRST RESYNC POINT # ITEM SETDFAULT C(7); # DEFAULT FOR THE SET # ITEM SPASS B; # LOOP EXIT VAR ON SYNTAX/SEMANTIC PASS # ITEM SVCBIN I; # BINARY VALUE OF SVC COUNT # ITEM SVCCNT I; # SVC COUNT # ITEM SVCCONT B; # LOOP EXIT VAR ON SVC CONVERSION PASS # ITEM SYNYMACTVE B; # SYNONYM ACTIVE FLAG # CONTROL EJECT; # * IF INPUT COMMAND STRING IS NULL, EXIT WITH * EC = UNRECOGNIZED COMMAND. # IF LEN EQ 0 THEN BEGIN EC = UNRGCMD$; GOTO EXIT; END # INITIALIZES VARIABLES AND ARRAYS # EC = NOERR$; # PRESET ERROR CODE TO NO ERROR # ET = " "; # PRESET ERROR TEXT TO BLANKS # SPASS = FALSE; # PRESET SYNTAX CHECKING PASS TO FALSE # ERROR = FALSE; # PRESET INPUT ERROR TO FALSE # # * START SYNTAX CHECKING OF THE INPUT COMMAND STRING UNTIL IT PASS * ON A SYNTAX LINE, OR *CST* HAS BEEN EXHAUSTED, OR ERROR IS * DETECTED IN INPUT. # FOR I = 0 STEP 1 WHILE ((NOT SPASS) AND (NOT ERROR)) DO BEGIN # PROCESSING SYNTAX TABLE # IPOS = 0; # RESET TO BEGINNING OF INPUT # SPOS = 0; # RESET TO BEGINNING OF A NEW SYTAX LINE # CURLINE = TRUE; # RESET CURRENT SYNTAX LINE TO TRUE # SSRGNT(CST[I], SPOS, 0, STOKEN, GNTEC); # GET FIRST STKN # IF STOKEN EQ EOL$ THEN BEGIN EC = UNRGCMD$; # END OF CST, UNRECOGNIZED COMMAND # ERROR = TRUE; END ELSE BEGIN # PROCESSING A NEW SYNTAX LINE # RESYNCFOUD = FALSE; # RESET RESYNC-FOUND TO FALSE # SYNYMACTVE = FALSE; # RESET SYNONYM_ACTIVE TO FALSE # FOR J = 0 STEP 1 UNTIL 30 DO BEGIN # CLEAR INTERMEDIATE PARAMETER LIST# PML$WORD[J] = " "; END OUTCNT = 0; # RESET OUTCNT # OP = 0; # RESET PARMLST INDEX TO FIRST ENTRY# PML$VALUE[OP] = STOKEN; # ADD FIRST S-TOKEN TO PARMLST # PML$CODE[OP] = VEB$; # ADD VERB CODE # OUTCNT = OUTCNT + 1; # INCREMENT OUTCNT # FOR J = 0 WHILE (STOKEN NQ COMMA$) DO # LOOP TIL STOKEN = "," # BEGIN SSRGNT(CST[I], SPOS, 0, STOKEN, GNTEC); IF STOKEN EQ PRMCODE$ THEN BEGIN # @, ADD NEXT TOKEN TO PARMLST # SSRGNT(CST[I], SPOS, 0, STOKEN, GNTEC); OP = OP + 1; # ALLOC A NEW ENTRY IN PARMLST # OUTCNT = OUTCNT + 1; # INCREMENT OUTCNT # PML$CODE[OP] = STOKEN; # ADD TOKEN TO PARMLST # END END # SKIP THE "," # FOR J = 0 WHILE ((NOT SPASS) AND (STOKEN NQ EOL$) AND (CURLINE) AND (NOT ERROR)) DO # LOOP TIL SYNTAX PASS, OR END OF SYN-LINE# # OR NOT CURRENT SYN-LINE, OR INPUT ERROR # BEGIN # CASE ON SYNTAX FLAG CHARACTERS # SSRGNT(CST[I], SPOS, 0, STOKEN, GNTEC); IF STOKEN EQ PRMCODE$ THEN BEGIN GOTO LLPRMCODE; END ELSE IF STOKEN EQ RPARENTH OR STOKEN EQ LPARENTH THEN BEGIN GOTO LLPARENTH ; END ELSE IF STOKEN EQ PRMTR$ THEN BEGIN GOTO LLPRMTR; END ELSE IF STOKEN EQ ENDMH$ THEN BEGIN GOTO LLENDMH; END ELSE IF STOKEN EQ RESYNC$ THEN BEGIN GOTO LLRESYNC; END ELSE IF STOKEN EQ BEGSYNST$ THEN BEGIN GOTO LLBEGSYNST; END ELSE IF STOKEN EQ ENDSYNST$ THEN BEGIN GOTO LLENDSYNST; END ELSE IF STOKEN EQ MESSAGE$ THEN BEGIN GOTO LLMESSAGE; END ELSE IF ((STOKEN EQ SYNSPTR$) OR (STOKEN EQ DFONEST$) OR (STOKEN EQ ONESET$)) THEN BEGIN GOTO ENDCASE1; END ELSE BEGIN GOTO LLOTHER; END LLPRMCODE: # @, STORE PARAMETER CODE IN OUTPUT # IF OP+1 GQ MAX THEN BEGIN EC = OUTPMSH$; #OUTPUT PARAMETER LIST TOO SHORT# ERROR = TRUE; END ELSE BEGIN SSRGNT(CST[I], SPOS, 0, STOKEN, GNTEC); IF STOKEN NQ EOL$ THEN BEGIN OP = OP + 1; # ALLOC A NEW ENTRY IN PARMLST # OUTCNT = OUTCNT + 1; # INCREMENT OUTCNT # PML$CODE[OP] = STOKEN; # ADD STOKEN TO PARMLST # END END GOTO ENDCASE1; LLPARENTH: IF IPOS EQ LEN THEN SPASS = TRUE ; ELSE BEGIN EC = UNRGCMD$ ; ET = ITOKEN ; ERROR = TRUE ; END GOTO ENDCASE1 ; LLPRMTR: # ?, ALPHA-NUM STRING EXPECT IN INPUT # IF IPOS GQ LEN THEN BEGIN EC = CMDMSGPRM$; # COMMAND MISSING PARAMETER # ERROR = TRUE; END ELSE BEGIN SSRGNT(CSTRING, IPOS, LEN, ITOKEN, GNTEC); IF GNTEC NQ 0 THEN BEGIN EC = PRMLNG$; # PARAMETER TOO LONG # ET = ITOKEN; ERROR = TRUE; END ELSE BEGIN IF PML$CODE[OP] EQ "NC0" # NCIR PARAMETER # THEN BEGIN SVCCNT = 0; # INITIALIZE SVC ACCUM. # SVCCONT = TRUE; # INITIALIZE LOOP CONTINUE VAR # FOR N = 0 STEP 1 WHILE SVCCONT DO BEGIN # CONVERT TOKEN TO INTEGER # SVCCONT = N LQ 3; # SCAN FOUR CHARACTERS # IF (CITOKEN GQ ZERO$) AND (CITOKEN LQ NINE$) THEN BEGIN SVCBIN = CITOKEN - O"33"; # CONVERT TO OCT.# SVCCNT = (SVCCNT * 10) + SVCBIN; # UPDATE ACCUM.# END ELSE IF CITOKEN NQ " " # CHAR NOT A SPACE # THEN BEGIN CURLINE = FALSE; # NEXT SYN-LINE # GOTO ENDCASE1; END ELSE SVCCONT = FALSE; # EXIT LOOP AND RANGE CHECK # END # FOR LOOP # IF SVCCNT GR MAXSVC # MAX NO. OF SVC CIRCUITS # THEN BEGIN EC = VALOUT$; # VALUE OUT-OF-RANGE # ET = ITOKEN; ERROR = TRUE; END ELSE BEGIN PML$NCVAL[OP] = SVCCNT; # STORE NO. SVCS # GOTO ENDCASE1; END END # IF NC0 # ELSE IF (C<0,1>ITOKEN GQ A$) AND (C<0,1>ITOKEN LQ NINE$) THEN BEGIN # ALPHA-NUM STRING # PML$VALUE[OP] = ITOKEN; # ADD ITOKEN TO PARMLST # END ELSE BEGIN CURLINE = FALSE; # NEXT SYN-LINE # END END END GOTO ENDCASE1; LLENDMH: # "^ ", END OR COMMA MATCHER # IF IPOS EQ LEN THEN BEGIN # NO "." IN INPUT, ONE IS ASSUMMED # SPASS = TRUE; # SYNTAX PASS SUCCESSFUL # END ELSE BEGIN SSRGNT(CSTRING, IPOS, LEN, ITOKEN, GNTEC); IF GNTEC NQ 0 THEN BEGIN EC = PRMLNG$; ET = ITOKEN; ERROR = TRUE; END ELSE BEGIN IF ITOKEN EQ PERIOD$ THEN BEGIN IF IPOS EQ LEN THEN # END OF INPUT STRING # BEGIN SPASS = TRUE; # I-TOKEN = ".", SYNTAX PASS # END ELSE BEGIN # PERIOD IN MIDST OF INPUT # EC = UNRGCMD$; ET = ITOKEN; ERROR = TRUE; END END ELSE IF ITOKEN EQ COMMA$ THEN BEGIN # I-TOKEN = "," # IF RESYNCFOUD THEN BEGIN # RESYNC FOUND # PSPOS = SPOS - 2; # GET PREVIOUS TOKEN # SSRGNT(CST[I], PSPOS, 0, PSTOKEN, GNTEC); IF PSTOKEN NQ RESYNC$ THEN BEGIN # "^" NOT PRECEDED BY "[" # SPOS = RESYNCPONT; # RESET TO RESYNC PT # END END ELSE BEGIN IF IPOS EQ LEN THEN # END OF INPUT "," INSTEAD OF"."# BEGIN EC = EXPRD$; # EXPECTING PERIOD # ET = ITOKEN; ERROR = TRUE; END END END ELSE # OTHER # BEGIN EC = EXPDCMA$; # EXPECTING PERIOD OR COMMA # ET = ITOKEN; ERROR = TRUE; END END END GOTO ENDCASE1; LLRESYNC: # [, FIRST RESYNC POINT # RESYNCFOUD = TRUE; # SET RESYNC-FOUND TRUE # RESYNCPONT = SPOS; # SET RESYNC-POINT TO CUR S-TKN # GOTO ENDCASE1; LLBEGSYNST: # <, BEING SYNONYM SET # SYNYMACTVE = TRUE; # SET SYNONYM-ACTIVE TRUE # GOTO ENDCASE1; LLENDSYNST: # >, END OF SYNONYM SET # SYNYMACTVE = FALSE; # SET SYNONYM_ACTIVE TO FALSE # IF RESYNCFOUD THEN BEGIN # RESYNC FOUND # FOR K = 0 WHILE ((STOKEN NQ RESYNC$) AND (CURLINE)) DO # SKIP FORWARD TO NEXT "[" # BEGIN SSRGNT(CST[I], SPOS, 0, STOKEN, GNTEC); IF STOKEN EQ EOL$ THEN BEGIN # END OF SYNTAX LINE # CURLINE = FALSE; # SKIP TO NEXT SYNTAX LINE # END END END ELSE BEGIN # RESYNC NOT FOUND # CURLINE = FALSE; # SKIP TO NEXT SYNTAX LINE # END GOTO ENDCASE1; LLMESSAGE: # &, TRNSFR ALL INPUT CHARS TO PARMLST # MSGLEN = LEN - IPOS; # MESSAGE LENGTH # IF MSGLEN GR MAXMSGL$ THEN BEGIN # MESSAGE EXCEEDS LIMIT # EC = MSGLNG$; # MESSAGE TOO LONG # ERROR = TRUE; END ELSE BEGIN # MESSAGE W/I LEN LIMIT # PML$MSGL[OP] = MSGLEN; # ADD MSG LENGTH TO PARMLST # # CONVERT IPOS INTO TABLE ORDINAL(IORD) AND STARTING # # BIT(IBIT) WITHIN WORD. # IORD = 0; IBIT = IPOS * CHARLEN$; FOR K = 0 WHILE (IPOS - CHARWD$) GR 0 DO BEGIN IPOS = IPOS - CHARWD$; IORD = IORD + 1; IBIT = IPOS * CHARLEN$; END DONE = FALSE; # RESET LOOP EXIT VAR TO FALSE # IF IBIT EQ 60 THEN # ADJUST BIT POSITION TO BEG OF NEXT WRD # BEGIN IORD = IORD + 1; IBIT = 0; END FOR K = 0 WHILE (NOT DONE) DO # LOOP TIL ALL CHARS STORED IN PARMLST # BEGIN IF MSGLEN GR CHARWD$ THEN BEGIN MSGLEN = MSGLEN - CHARWD$; # DECREMENT MSGLEN # BLEN = CHARWD$ * CHARLEN$; # STORE WHOLD WORD # END ELSE BEGIN BLEN = MSGLEN * CHARLEN$; # STORE MSGLEN NO OF CHAR # DONE = TRUE; # AND THIS IS IT # END IF OP + 1 GQ MAX THEN BEGIN EC = OUTPMSH$; # PARMLST TOO SHORT # ERROR = TRUE; DONE = TRUE; END ELSE BEGIN SSBEBF(CSTRING, IORD, IBIT, BLEN, RESULT); OP = OP + 1; # ALLOC NEW ENTRY IN PARMLST # OUTCNT = OUTCNT + 1; # INCREMENT OUTCNT, STORE CHARS # SORD = 0; SBIT = 0; SSBSBF(PARMLST[OP], SORD, SBIT, BLEN, RESULT); END END SPASS = TRUE; # TERMINATE SYNTAX CHECKING # END GOTO ENDCASE1; LLOTHER: # OTHER, STRING TO BE COMPARED W/ INPUT # IF IPOS GQ LEN THEN BEGIN # END OF INPUT STRING # EC = CMDMSGPRM$; # COMMAND MISSING PARAMETER # ERROR = TRUE; END ELSE BEGIN IIPOS = IPOS; # SAVE CUR CHAR POSITION # SSRGNT(CSTRING, IPOS, LEN, ITOKEN, GNTEC); IF GNTEC NQ 0 THEN BEGIN EC = PRMLNG$; ET = ITOKEN; ERROR = TRUE; END ELSE BEGIN IF STOKEN EQ ITOKEN THEN BEGIN # INPUT TOKEN MATCH # IF SYNYMACTVE THEN BEGIN FOR K = 0 WHILE (STOKEN NQ ENDSYNST$) DO BEGIN # SKIP FORWARD TO NEXT ">" TKN # SSRGNT(CST[I], SPOS, 0, STOKEN, GNTEC); END SYNYMACTVE = FALSE; # SET SYNONYM-ACTIVE FALSE # END END ELSE BEGIN # I-TOKEN NOT MATCH S-TOKEN # IPOS = IIPOS; # RESET NXT POS TO CUR POS # IF NOT SYNYMACTVE THEN BEGIN # SYNONYM NOT ACTIVE # IF NOT RESYNCFOUD THEN BEGIN # RESYNC NOT FOUND # CURLINE = FALSE; # SKIP TO NEXT SYNTAX LINE # END ELSE BEGIN # RESYNC FOUND # FOR K = 0 WHILE ((STOKEN NQ RESYNC$) AND (CURLINE)) DO BEGIN # SKIP FORWARD TO NEXT "[" # SSRGNT(CST[I], SPOS, 0, STOKEN, GNTEC); IF STOKEN EQ EOL$ THEN BEGIN # END OF SYNTAX LINE # CURLINE = FALSE; # SKIP TO NEXT SYN-LINE # END ELSE BEGIN SYNYMACTVE = FALSE; # SET SYNONYM-ACT FALSE # END END END END END END END GOTO ENDCASE1; ENDCASE1: END # END CASE ON SYNTAX FLAGS # END # PROCESSING A NEW SYNTAX LINE # END # END PROCESSING SYNTAX TABLE # IF NOT SPASS THEN GOTO EXIT; # FAIL SYNTAX CHECKING, EXIT WITH ERROR # # * START SEMANTIC CHECKING USING THE INTERMEDIATE PARAMETER LIST AND * THE SYNTAX LINE(LINE I-1) THAT THE INPUT LINE JUST PASSED AT. * AT THIS TIME ANY DUPLICATE KEYWORDS, MISSING PARAMETERS AND * DEFAULTS TO BE INSERTED ARE RECOGNIZED AND ADDED TO THE OUPUT * OR THE ENTIRE COMMAND REJECTED IF WHAT WAS ENTERED IS INCORRECT. # FRSTEOS = FALSE; # CLEAR FIRST END OF SET FLAG # I = I - 1; # RE-POSITION TO THE JUST PASSED SYN-LINE # SPOS = 0; # RESET TO BEGINNING OF THE SYN-LINE # ERROR = FALSE; # SET ERROR FLAG TO FALSE # STOKEN = " "; # SET TO BLANK TO FORCE FIRST TIME LOOP # # * CLEAR OUTPUT PARMETER LIST. # FOR J = 0 STEP 1 UNTIL MAX DO BEGIN OPM$WORD[J] = " "; END OP = 0; # SET OUTPARM INDEX TO 0 # OPM$WORD[OP] = PML$WORD[0]; # COPY COMMAND VERB OVER # FOR J = 0 WHILE ((STOKEN NQ EOL$) AND (NOT ERROR)) DO # LOOP TIL END OF SYNTAX LINE OR ERROR # BEGIN EOSET = FALSE; # SET END OF SET TO FALSE # MEMCNT = 0; # SET MEMBER COUNT TO 0 # MEMREQD = FALSE; # SET MEMBER-REQUIRED TO FALSE # SETDFAULT = " "; # SET SET-DEFAULT TO EMPTY # SSRGNT(CST[I], SPOS, 0, STOKEN, GNTEC); FOR K = 0 WHILE ((STOKEN NQ EOL$) AND (NOT ERROR) AND (NOT EOSET)) DO # LOOP TIL END OF LINE, OR SET, OR ERROR # BEGIN SSRGNT(CST[I], SPOS, 0, STOKEN, GNTEC); IF STOKEN EQ PRMCODE$ THEN BEGIN GOTO LLSPRMCODE; END ELSE IF STOKEN EQ DFONEST$ THEN BEGIN GOTO LLDFONEST; END ELSE IF STOKEN EQ ONESET$ THEN BEGIN GOTO LLONESET; END ELSE BEGIN GOTO ENDCASE2; END LLSPRMCODE: # @, PARAMETER CODE # FOUND = FALSE; SSRGNT(CST[I], SPOS, 0, STOKEN, GNTEC); # GET STOKEN # FOR L = 1 STEP 1 WHILE ((L LS OUTCNT) AND (NOT FOUND)) DO BEGIN # SEE IF PARM CODE APPEARS IN PARMLST # IF STOKEN EQ PML$CODE[L] THEN BEGIN OP = OP + 1; # BUMP OUTPARM INDEX # OPM$WORD[OP] = PML$WORD[L]; # COPY PARM TO OUTPARM # FOR M=L+1 STEP 1 WHILE M LS OUTCNT DO # CHECK FOR DUPLICATE DECLARATION # BEGIN IF STOKEN EQ PML$CODE[M] THEN # IF DUPLICATE DECLARATIN FOUND # BEGIN ERROR = TRUE; # SET ERROR INDICATOR # EC = INVCMPRM$; # SET ERROR CODE # END END IF PML$CODE[L] EQ MS0$ THEN BEGIN # MESSAGE CMD- COPY ENTIRE MESSAGE # L = L + 1; FOR M = OP+1 STEP 1 UNTIL OUTCNT-1 DO BEGIN OPM$WORD[M] = PML$WORD[L]; L = L + 1; END END FOUND = TRUE; END END IF FOUND THEN BEGIN # PARM CODE APPEARS IN PARMLST # IF FRSTEOS THEN # IF FIRST END OF SET FOUND # BEGIN MEMCNT = MEMCNT + 1; # INCREMENT MEMBER COUNT # END IF MEMCNT GR 1 THEN BEGIN EC = INVCMPRM$; # INVALID COMBINATION OF PARM # ERROR = TRUE; END END GOTO ENDCASE2; LLDFONEST: # !, DEFAULT, OR ONE MEMBER OF SET # SSRGNT(CST[I], SPOS, 0, STOKEN, GNTEC); # GET NEXT TOKN# IF STOKEN EQ PRMCODE$ THEN BEGIN # STOKEN = "@" # SSRGNT(CST[I], SPOS, 0, STOKEN, GNTEC); FOUND = FALSE; FOR L = 1 STEP 1 WHILE ((L LS OUTCNT) AND (NOT FOUND)) DO # SEE IF NEXT TKN IN PARMLST # BEGIN IF STOKEN EQ PML$CODE[L] THEN BEGIN MEMCNT = MEMCNT + 1; # INCREMENT MEMBER COUNT # IF MEMCNT GR 1 THEN BEGIN EC = INVCMPRM$; # INVALID COMBINATION OF PARM # ERROR = TRUE; GOTO ENDCASE2; END OP = OP + 1; OPM$WORD[OP] = PML$WORD[L]; FOUND = TRUE; END END IF NOT FOUND THEN BEGIN # NEXT STOKEN NOT IN PARMLST # SETDFAULT = STOKEN; # SAVE IT AS SET-DEFAULT # END END ELSE BEGIN # ! NOT FOLLOWED BY @ # MEMREQD = TRUE; # SET MEMBER REQUIRED TO TRUE # END GOTO ENDCASE2; LLONESET: # \, END OF SET # IF MEMCNT EQ 0 THEN BEGIN # MEMBER-COUNT = 0 # IF SETDFAULT NQ " " THEN BEGIN # SET DEFAULT AVAILABLE # IF OUTCNT LS MAX THEN BEGIN PML$CODE[OUTCNT] = SETDFAULT; # ADD SDF TO PARMLST # OPM$CODE[OUTCNT] = SETDFAULT; # ADD SDF TO OUTPARM # OUTCNT = OUTCNT + 1; # INCREMENT OUTCNT # END ELSE BEGIN EC = OUTPMSH$; # PARMLST TOO SHORT # ERROR = TRUE; END END ELSE BEGIN # SET-DEFAULT EMTPY # IF MEMREQD THEN BEGIN # MEMBER REQUIRED TRUE # EC = CMDMSGPRM$; # COMMAND MISSING PARAMETER # ERROR = TRUE; END END END IF NOT FRSTEOS THEN # IF 1ST END OF SET NOT FOUND YET # BEGIN FRSTEOS = TRUE; # SET FIRST END OF SET FLAG # END ELSE BEGIN EOSET = TRUE; # SET END OF SET FLAG # END GOTO ENDCASE2; ENDCASE2: END # END OF CASE ON SEMANTIC FLAGS # END # END OF WHOLE SYNTAX LINE LOOP # EXIT: END # SSRRCS # TERM