diff options
Diffstat (limited to 'src/boot/strap/parser.clisp')
| -rw-r--r-- | src/boot/strap/parser.clisp | 1331 |
1 files changed, 1331 insertions, 0 deletions
diff --git a/src/boot/strap/parser.clisp b/src/boot/strap/parser.clisp new file mode 100644 index 00000000..cfc9b0fa --- /dev/null +++ b/src/boot/strap/parser.clisp @@ -0,0 +1,1331 @@ +(EVAL-WHEN (:COMPILE-TOPLEVEL) (PROVIDE "boot-parser")) + +(IMPORT-MODULE "includer") + +(IMPORT-MODULE "scanner") + +(IMPORT-MODULE "ast") + +(IN-PACKAGE "BOOTTRAN") + +(DEFPARAMETER |$sawParenthesizedHead| NIL) + +(DEFPARAMETER |$bodyHasReturn| NIL) + +(DEFUN |bpFirstToken| () + (PROG () + (DECLARE (SPECIAL |$ttok| |$stok| |$inputStream|)) + (RETURN + (PROGN + (SETQ |$stok| + (COND + ((NULL |$inputStream|) + (|shoeTokConstruct| 'ERROR 'NOMORE + (|shoeTokPosn| |$stok|))) + ('T (CAR |$inputStream|)))) + (SETQ |$ttok| (|shoeTokPart| |$stok|)) + T)))) + +(DEFUN |bpFirstTok| () + (PROG () + (DECLARE (SPECIAL |$bpCount| |$bpParenCount| |$ttok| |$stok| + |$inputStream|)) + (RETURN + (PROGN + (SETQ |$stok| + (COND + ((NULL |$inputStream|) + (|shoeTokConstruct| 'ERROR 'NOMORE + (|shoeTokPosn| |$stok|))) + ('T (CAR |$inputStream|)))) + (SETQ |$ttok| (|shoeTokPart| |$stok|)) + (COND + ((AND (< 0 |$bpParenCount|) (EQCAR |$stok| 'KEY)) + (COND + ((EQ |$ttok| 'SETTAB) + (PROGN (SETQ |$bpCount| (+ |$bpCount| 1)) (|bpNext|))) + ((EQ |$ttok| 'BACKTAB) + (PROGN (SETQ |$bpCount| (- |$bpCount| 1)) (|bpNext|))) + ((EQ |$ttok| 'BACKSET) (|bpNext|)) + (#0='T T))) + (#0# T)))))) + +(DEFUN |bpNext| () + (PROG () + (DECLARE (SPECIAL |$inputStream|)) + (RETURN + (PROGN + (SETQ |$inputStream| (CDR |$inputStream|)) + (|bpFirstTok|))))) + +(DEFUN |bpNextToken| () + (PROG () + (DECLARE (SPECIAL |$inputStream|)) + (RETURN + (PROGN + (SETQ |$inputStream| (CDR |$inputStream|)) + (|bpFirstToken|))))) + +(DEFUN |bpState| () + (PROG () + (DECLARE (SPECIAL |$bpCount| |$bpParenCount| |$stack| + |$inputStream|)) + (RETURN (LIST |$inputStream| |$stack| |$bpParenCount| |$bpCount|)))) + +(DEFUN |bpRestore| (|x|) + (PROG () + (DECLARE (SPECIAL |$bpCount| |$bpParenCount| |$stack| + |$inputStream|)) + (RETURN + (PROGN + (SETQ |$inputStream| (CAR |x|)) + (|bpFirstToken|) + (SETQ |$stack| (CADR |x|)) + (SETQ |$bpParenCount| (CADDR |x|)) + (SETQ |$bpCount| (CADDDR |x|)) + T)))) + +(DEFUN |bpPush| (|x|) + (PROG () + (DECLARE (SPECIAL |$stack|)) + (RETURN (SETQ |$stack| (CONS |x| |$stack|))))) + +(DEFUN |bpPushId| () + (PROG () + (DECLARE (SPECIAL |$stack| |$ttok|)) + (RETURN (SETQ |$stack| (CONS (|bfReName| |$ttok|) |$stack|))))) + +(DEFUN |bpPop1| () + (PROG (|a|) + (DECLARE (SPECIAL |$stack|)) + (RETURN + (PROGN + (SETQ |a| (CAR |$stack|)) + (SETQ |$stack| (CDR |$stack|)) + |a|)))) + +(DEFUN |bpPop2| () + (PROG (|a|) + (DECLARE (SPECIAL |$stack|)) + (RETURN + (PROGN + (SETQ |a| (CADR |$stack|)) + (RPLACD |$stack| (CDDR |$stack|)) + |a|)))) + +(DEFUN |bpPop3| () + (PROG (|a|) + (DECLARE (SPECIAL |$stack|)) + (RETURN + (PROGN + (SETQ |a| (CADDR |$stack|)) + (RPLACD (CDR |$stack|) (CDDDR |$stack|)) + |a|)))) + +(DEFUN |bpIndentParenthesized| (|f|) + (PROG (|$bpCount| |a|) + (DECLARE (SPECIAL |$inputStream| |$bpCount| |$bpParenCount| + |$stok|)) + (RETURN + (PROGN + (SETQ |$bpCount| 0) + (SETQ |a| |$stok|) + (COND + ((|bpEqPeek| 'OPAREN) + (SETQ |$bpParenCount| (+ |$bpParenCount| 1)) (|bpNext|) + (COND + ((AND (APPLY |f| NIL) (|bpFirstTok|) + (OR (|bpEqPeek| 'CPAREN) (|bpParenTrap| |a|))) + (SETQ |$bpParenCount| (- |$bpParenCount| 1)) + (|bpNextToken|) + (COND + ((EQL |$bpCount| 0) T) + (#0='T + (PROGN + (SETQ |$inputStream| + (APPEND (|bpAddTokens| |$bpCount|) + |$inputStream|)) + (|bpFirstToken|) + (COND + ((EQL |$bpParenCount| 0) (PROGN (|bpCancel|) T)) + (#0# T)))))) + ((|bpEqPeek| 'CPAREN) (|bpPush| (|bfTuple| NIL)) + (SETQ |$bpParenCount| (- |$bpParenCount| 1)) + (|bpNextToken|) T) + (#1='T (|bpParenTrap| |a|)))) + (#1# NIL)))))) + +(DEFUN |bpParenthesized| (|f|) + (PROG (|a|) + (DECLARE (SPECIAL |$stok|)) + (RETURN + (PROGN + (SETQ |a| |$stok|) + (COND + ((|bpEqKey| 'OPAREN) + (COND + ((AND (APPLY |f| NIL) + (OR (|bpEqKey| 'CPAREN) (|bpParenTrap| |a|))) + T) + ((|bpEqKey| 'CPAREN) (|bpPush| (|bfTuple| NIL)) T) + (#0='T (|bpParenTrap| |a|)))) + (#0# NIL)))))) + +(DEFUN |bpBracket| (|f|) + (PROG (|a|) + (DECLARE (SPECIAL |$stok|)) + (RETURN + (PROGN + (SETQ |a| |$stok|) + (COND + ((|bpEqKey| 'OBRACK) + (COND + ((AND (APPLY |f| NIL) + (OR (|bpEqKey| 'CBRACK) (|bpBrackTrap| |a|))) + (|bpPush| (|bfBracket| (|bpPop1|)))) + ((|bpEqKey| 'CBRACK) (|bpPush| NIL)) + (#0='T (|bpBrackTrap| |a|)))) + (#0# NIL)))))) + +(DEFUN |bpPileBracketed| (|f|) + (PROG () + (RETURN + (COND + ((|bpEqKey| 'SETTAB) + (COND + ((|bpEqKey| 'BACKTAB) T) + ((AND (APPLY |f| NIL) + (OR (|bpEqKey| 'BACKTAB) (|bpPileTrap|))) + (|bpPush| (|bfPile| (|bpPop1|)))) + (#0='T NIL))) + (#0# NIL))))) + +(DEFUN |bpListof| (|f| |str1| |g|) + (PROG (|a|) + (DECLARE (SPECIAL |$stack|)) + (RETURN + (COND + ((APPLY |f| NIL) + (COND + ((AND (|bpEqKey| |str1|) (OR (APPLY |f| NIL) (|bpTrap|))) + (SETQ |a| |$stack|) (SETQ |$stack| NIL) + (LOOP + (COND + ((NOT (AND (|bpEqKey| |str1|) + (OR (APPLY |f| NIL) (|bpTrap|)))) + (RETURN NIL)) + ('T 0))) + (SETQ |$stack| (CONS (NREVERSE |$stack|) |a|)) + (|bpPush| + (FUNCALL |g| + (CONS (|bpPop3|) (CONS (|bpPop2|) (|bpPop1|)))))) + (#0='T T))) + (#0# NIL))))) + +(DEFUN |bpListofFun| (|f| |h| |g|) + (PROG (|a|) + (DECLARE (SPECIAL |$stack|)) + (RETURN + (COND + ((APPLY |f| NIL) + (COND + ((AND (APPLY |h| NIL) (OR (APPLY |f| NIL) (|bpTrap|))) + (SETQ |a| |$stack|) (SETQ |$stack| NIL) + (LOOP + (COND + ((NOT (AND (APPLY |h| NIL) + (OR (APPLY |f| NIL) (|bpTrap|)))) + (RETURN NIL)) + ('T 0))) + (SETQ |$stack| (CONS (NREVERSE |$stack|) |a|)) + (|bpPush| + (FUNCALL |g| + (|bfListOf| + (CONS (|bpPop3|) + (CONS (|bpPop2|) (|bpPop1|))))))) + (#0='T T))) + (#0# NIL))))) + +(DEFUN |bpList| (|f| |str1| |g|) + (PROG (|a|) + (DECLARE (SPECIAL |$stack|)) + (RETURN + (COND + ((APPLY |f| NIL) + (COND + ((AND (|bpEqKey| |str1|) (OR (APPLY |f| NIL) (|bpTrap|))) + (SETQ |a| |$stack|) (SETQ |$stack| NIL) + (LOOP + (COND + ((NOT (AND (|bpEqKey| |str1|) + (OR (APPLY |f| NIL) (|bpTrap|)))) + (RETURN NIL)) + ('T 0))) + (SETQ |$stack| (CONS (NREVERSE |$stack|) |a|)) + (|bpPush| + (FUNCALL |g| + (CONS (|bpPop3|) (CONS (|bpPop2|) (|bpPop1|)))))) + (#0='T (|bpPush| (FUNCALL |g| (LIST (|bpPop1|))))))) + (#0# (|bpPush| (FUNCALL |g| NIL))))))) + +(DEFUN |bpOneOrMore| (|f|) + (PROG (|a|) + (DECLARE (SPECIAL |$stack|)) + (RETURN + (COND + ((APPLY |f| NIL) + (PROGN + (SETQ |a| |$stack|) + (SETQ |$stack| NIL) + (LOOP (COND ((NOT (APPLY |f| NIL)) (RETURN NIL)) ('T 0))) + (SETQ |$stack| (CONS (NREVERSE |$stack|) |a|)) + (|bpPush| (CONS (|bpPop2|) (|bpPop1|))))) + ('T NIL))))) + +(DEFUN |bpAnyNo| (|s|) + (PROG () + (RETURN + (PROGN + (LOOP (COND ((NOT (APPLY |s| NIL)) (RETURN NIL)) ('T 0))) + T)))) + +(DEFUN |bpAndOr| (|keyword| |p| |f|) + (PROG () + (RETURN + (AND (|bpEqKey| |keyword|) (OR (APPLY |p| NIL) (|bpTrap|)) + (|bpPush| (FUNCALL |f| (|bpPop1|))))))) + +(DEFUN |bpConditional| (|f|) + (PROG () + (RETURN + (COND + ((AND (|bpEqKey| 'IF) (OR (|bpWhere|) (|bpTrap|)) + (OR (|bpEqKey| 'BACKSET) T)) + (COND + ((|bpEqKey| 'SETTAB) + (COND + ((|bpEqKey| 'THEN) + (AND (OR (APPLY |f| NIL) (|bpTrap|)) (|bpElse| |f|) + (|bpEqKey| 'BACKTAB))) + (#0='T (|bpMissing| 'THEN)))) + ((|bpEqKey| 'THEN) + (AND (OR (APPLY |f| NIL) (|bpTrap|)) (|bpElse| |f|))) + (#0# (|bpMissing| '|then|)))) + (#0# NIL))))) + +(DEFUN |bpElse| (|f|) + (PROG (|a|) + (RETURN + (PROGN + (SETQ |a| (|bpState|)) + (COND + ((|bpBacksetElse|) + (AND (OR (APPLY |f| NIL) (|bpTrap|)) + (|bpPush| (|bfIf| (|bpPop3|) (|bpPop2|) (|bpPop1|))))) + ('T (|bpRestore| |a|) + (|bpPush| (|bfIfThenOnly| (|bpPop2|) (|bpPop1|))))))))) + +(DEFUN |bpBacksetElse| () + (PROG () + (RETURN + (COND + ((|bpEqKey| 'BACKSET) (|bpEqKey| 'ELSE)) + ('T (|bpEqKey| 'ELSE)))))) + +(DEFUN |bpEqPeek| (|s|) + (PROG () + (DECLARE (SPECIAL |$ttok| |$stok|)) + (RETURN (AND (EQCAR |$stok| 'KEY) (EQ |s| |$ttok|))))) + +(DEFUN |bpEqKey| (|s|) + (PROG () + (DECLARE (SPECIAL |$ttok| |$stok|)) + (RETURN (AND (EQCAR |$stok| 'KEY) (EQ |s| |$ttok|) (|bpNext|))))) + +(DEFUN |bpEqKeyNextTok| (|s|) + (PROG () + (DECLARE (SPECIAL |$ttok| |$stok|)) + (RETURN + (AND (EQCAR |$stok| 'KEY) (EQ |s| |$ttok|) (|bpNextToken|))))) + +(DEFUN |bpPileTrap| () (PROG () (RETURN (|bpMissing| 'BACKTAB)))) + +(DEFUN |bpBrackTrap| (|x|) + (PROG () (RETURN (|bpMissingMate| '] |x|)))) + +(DEFUN |bpParenTrap| (|x|) + (PROG () (RETURN (|bpMissingMate| '|)| |x|)))) + +(DEFUN |bpMissingMate| (|close| |open|) + (PROG () + (RETURN + (PROGN + (|bpSpecificErrorAtToken| |open| "possibly missing mate") + (|bpMissing| |close|))))) + +(DEFUN |bpMissing| (|s|) + (PROG () + (RETURN + (PROGN + (|bpSpecificErrorHere| + (CONCAT (PNAME |s|) " possibly missing")) + (THROW 'TRAPPOINT 'TRAPPED))))) + +(DEFUN |bpCompMissing| (|s|) + (PROG () (RETURN (OR (|bpEqKey| |s|) (|bpMissing| |s|))))) + +(DEFUN |bpTrap| () + (PROG () + (RETURN + (PROGN (|bpGeneralErrorHere|) (THROW 'TRAPPOINT 'TRAPPED))))) + +(DEFUN |bpRecoverTrap| () + (PROG (|pos2| |pos1|) + (DECLARE (SPECIAL |$stok|)) + (RETURN + (PROGN + (|bpFirstToken|) + (SETQ |pos1| (|shoeTokPosn| |$stok|)) + (|bpMoveTo| 0) + (SETQ |pos2| (|shoeTokPosn| |$stok|)) + (|bpIgnoredFromTo| |pos1| |pos2|) + (|bpPush| (LIST (LIST "pile syntax error"))))))) + +(DEFUN |bpListAndRecover| (|f|) + (PROG (|found| |c| |done| |b| |a|) + (DECLARE (SPECIAL |$inputStream| |$stack|)) + (RETURN + (PROGN + (SETQ |a| |$stack|) + (SETQ |b| NIL) + (SETQ |$stack| NIL) + (SETQ |done| NIL) + (SETQ |c| |$inputStream|) + (LOOP + (COND + (|done| (RETURN NIL)) + ('T + (PROGN + (SETQ |found| (CATCH 'TRAPPOINT (APPLY |f| NIL))) + (COND + ((EQ |found| 'TRAPPED) (SETQ |$inputStream| |c|) + (|bpRecoverTrap|)) + ((NULL |found|) (SETQ |$inputStream| |c|) + (|bpGeneralErrorHere|) (|bpRecoverTrap|))) + (COND + ((|bpEqKey| 'BACKSET) (SETQ |c| |$inputStream|)) + ((OR (|bpEqPeek| 'BACKTAB) (NULL |$inputStream|)) + (SETQ |done| T)) + (#0='T (SETQ |$inputStream| |c|) + (|bpGeneralErrorHere|) (|bpRecoverTrap|) + (COND + ((OR (|bpEqPeek| 'BACKTAB) (NULL |$inputStream|)) + (SETQ |done| T)) + (#0# (|bpNext|) (SETQ |c| |$inputStream|))))) + (SETQ |b| (CONS (|bpPop1|) |b|)))))) + (SETQ |$stack| |a|) + (|bpPush| (NREVERSE |b|)))))) + +(DEFUN |bpMoveTo| (|n|) + (PROG () + (DECLARE (SPECIAL |$bpParenCount| |$bpCount| |$inputStream|)) + (RETURN + (COND + ((NULL |$inputStream|) T) + ((|bpEqPeek| 'BACKTAB) + (COND + ((EQL |n| 0) T) + (#0='T + (PROGN + (|bpNextToken|) + (SETQ |$bpCount| (- |$bpCount| 1)) + (|bpMoveTo| (- |n| 1)))))) + ((|bpEqPeek| 'BACKSET) + (COND + ((EQL |n| 0) T) + (#0# (PROGN (|bpNextToken|) (|bpMoveTo| |n|))))) + ((|bpEqPeek| 'SETTAB) + (PROGN (|bpNextToken|) (|bpMoveTo| (+ |n| 1)))) + ((|bpEqPeek| 'OPAREN) + (PROGN + (|bpNextToken|) + (SETQ |$bpParenCount| (+ |$bpParenCount| 1)) + (|bpMoveTo| |n|))) + ((|bpEqPeek| 'CPAREN) + (PROGN + (|bpNextToken|) + (SETQ |$bpParenCount| (- |$bpParenCount| 1)) + (|bpMoveTo| |n|))) + (#0# (PROGN (|bpNextToken|) (|bpMoveTo| |n|))))))) + +(DEFUN |bpQualifiedName| () + (PROG () + (DECLARE (SPECIAL |$stok|)) + (RETURN + (COND + ((|bpEqPeek| 'COLON-COLON) + (PROGN + (|bpNext|) + (AND (EQCAR |$stok| 'ID) (|bpPushId|) (|bpNext|) + (|bpPush| (|bfColonColon| (|bpPop2|) (|bpPop1|)))))) + ('T NIL))))) + +(DEFUN |bpName| () + (PROG () + (DECLARE (SPECIAL |$stok|)) + (RETURN + (COND + ((EQCAR |$stok| 'ID) + (PROGN + (|bpPushId|) + (|bpNext|) + (|bpAnyNo| #'|bpQualifiedName|))) + ('T NIL))))) + +(DEFUN |bpConstTok| () + (PROG () + (DECLARE (SPECIAL |$ttok| |$stok|)) + (RETURN + (COND + ((MEMQ (|shoeTokType| |$stok|) '(INTEGER FLOAT)) + (PROGN (|bpPush| |$ttok|) (|bpNext|))) + ((EQCAR |$stok| 'LISP) + (AND (|bpPush| (|bfReadLisp| |$ttok|)) (|bpNext|))) + ((EQCAR |$stok| 'LISPEXP) (AND (|bpPush| |$ttok|) (|bpNext|))) + ((EQCAR |$stok| 'LINE) + (AND (|bpPush| (LIST '+LINE |$ttok|)) (|bpNext|))) + ((|bpEqPeek| 'QUOTE) + (PROGN + (|bpNext|) + (AND (OR (|bpSexp|) (|bpTrap|)) + (|bpPush| (|bfSymbol| (|bpPop1|)))))) + ('T (|bpString|)))))) + +(DEFUN |bpModule| () + (PROG () + (RETURN + (COND + ((|bpEqKey| 'MODULE) + (AND (|bpConstTok|) (|bpPush| (|Module| (|bpPop1|))))) + ('T NIL))))) + +(DEFUN |bpImport| () + (PROG () + (RETURN + (COND + ((|bpEqKey| 'IMPORT) + (OR (AND (|bpName|) (OR (|bpEqKey| 'FOR) (|bpTrap|)) + (|bpSignature|) + (|bpPush| (|ImportSignature| (|bpPop2|) (|bpPop1|)))) + (AND (|bpConstTok|) (|bpPush| (|Import| (|bpPop1|)))))) + ('T NIL))))) + +(DEFUN |bpTypeAliasDefition| () + (PROG () + (RETURN + (AND (OR (|bpName|) (|bpTrap|)) (|bpEqKey| 'TDEF) (|bpLogical|) + (|bpPush| (|TypeAlias| (|bpPop2|) NIL (|bpPop1|))))))) + +(DEFUN |bpSignature| () + (PROG () + (RETURN + (AND (|bpName|) (|bpEqKey| 'COLON) (|bpMapping|) + (|bpPush| (|Signature| (|bpPop2|) (|bpPop1|))))))) + +(DEFUN |bpMapping| () + (PROG () + (RETURN + (AND (OR (|bpName|) (|bpIdList|)) (|bpEqKey| 'ARROW) (|bpName|) + (|bpPush| (|Mapping| (|bpPop1|) (|bpPop1|))))))) + +(DEFUN |bpCancel| () + (PROG (|a|) + (RETURN + (PROGN + (SETQ |a| (|bpState|)) + (COND + ((|bpEqKeyNextTok| 'SETTAB) + (COND + ((|bpCancel|) + (COND + ((|bpEqKeyNextTok| 'BACKTAB) T) + (#0='T (|bpRestore| |a|) NIL))) + ((|bpEqKeyNextTok| 'BACKTAB) T) + (#0# (|bpRestore| |a|) NIL))) + (#0# NIL)))))) + +(DEFUN |bpAddTokens| (|n|) + (PROG () + (DECLARE (SPECIAL |$stok|)) + (RETURN + (COND + ((EQL |n| 0) NIL) + ((< 0 |n|) + (CONS (|shoeTokConstruct| 'KEY 'SETTAB + (|shoeTokPosn| |$stok|)) + (|bpAddTokens| (- |n| 1)))) + ('T + (CONS (|shoeTokConstruct| 'KEY 'BACKTAB + (|shoeTokPosn| |$stok|)) + (|bpAddTokens| (+ |n| 1)))))))) + +(DEFUN |bpExceptions| () + (PROG () + (RETURN + (OR (|bpEqPeek| 'DOT) (|bpEqPeek| 'QUOTE) (|bpEqPeek| 'OPAREN) + (|bpEqPeek| 'CPAREN) (|bpEqPeek| 'SETTAB) + (|bpEqPeek| 'BACKTAB) (|bpEqPeek| 'BACKSET))))) + +(DEFUN |bpSexpKey| () + (PROG (|a|) + (DECLARE (SPECIAL |$ttok| |$stok|)) + (RETURN + (COND + ((AND (EQCAR |$stok| 'KEY) (NULL (|bpExceptions|))) + (PROGN + (SETQ |a| (GET |$ttok| 'SHOEINF)) + (COND + ((NULL |a|) (AND (|bpPush| |$ttok|) (|bpNext|))) + (#0='T (AND (|bpPush| |a|) (|bpNext|)))))) + (#0# NIL))))) + +(DEFUN |bpAnyId| () + (PROG () + (DECLARE (SPECIAL |$ttok| |$stok|)) + (RETURN + (OR (AND (|bpEqKey| 'MINUS) + (OR (EQCAR |$stok| 'INTEGER) (|bpTrap|)) + (|bpPush| (- |$ttok|)) (|bpNext|)) + (|bpSexpKey|) + (AND (MEMQ (|shoeTokType| |$stok|) + '(ID INTEGER STRING FLOAT)) + (|bpPush| |$ttok|) (|bpNext|)))))) + +(DEFUN |bpSexp| () + (PROG () + (RETURN + (OR (|bpAnyId|) + (AND (|bpEqKey| 'QUOTE) (OR (|bpSexp|) (|bpTrap|)) + (|bpPush| (|bfSymbol| (|bpPop1|)))) + (|bpIndentParenthesized| #'|bpSexp1|))))) + +(DEFUN |bpSexp1| () + (PROG () + (RETURN + (OR (AND (|bpFirstTok|) (|bpSexp|) + (OR (AND (|bpEqKey| 'DOT) (|bpSexp|) + (|bpPush| (CONS (|bpPop2|) (|bpPop1|)))) + (AND (|bpSexp1|) + (|bpPush| (CONS (|bpPop2|) (|bpPop1|)))))) + (|bpPush| NIL))))) + +(DEFUN |bpPrimary1| () + (PROG () + (RETURN + (OR (|bpName|) (|bpDot|) (|bpConstTok|) (|bpConstruct|) + (|bpCase|) (|bpStruct|) (|bpPDefinition|) + (|bpBPileDefinition|))))) + +(DEFUN |bpPrimary| () + (PROG () + (RETURN + (AND (|bpFirstTok|) (OR (|bpPrimary1|) (|bpPrefixOperator|)))))) + +(DEFUN |bpDot| () + (PROG () (RETURN (AND (|bpEqKey| 'DOT) (|bpPush| (|bfDot|)))))) + +(DEFUN |bpPrefixOperator| () + (PROG () + (DECLARE (SPECIAL |$ttok| |$stok|)) + (RETURN + (AND (EQCAR |$stok| 'KEY) (GET |$ttok| 'SHOEPRE) (|bpPushId|) + (|bpNext|))))) + +(DEFUN |bpInfixOperator| () + (PROG () + (DECLARE (SPECIAL |$ttok| |$stok|)) + (RETURN + (AND (EQCAR |$stok| 'KEY) (GET |$ttok| 'SHOEINF) (|bpPushId|) + (|bpNext|))))) + +(DEFUN |bpSelector| () + (PROG () + (RETURN + (AND (|bpEqKey| 'DOT) + (OR (AND (|bpPrimary|) + (|bpPush| (|bfElt| (|bpPop2|) (|bpPop1|)))) + (|bpPush| (|bfSuffixDot| (|bpPop1|)))))))) + +(DEFUN |bpOperator| () + (PROG () (RETURN (AND (|bpPrimary|) (|bpAnyNo| #'|bpSelector|))))) + +(DEFUN |bpApplication| () + (PROG () + (RETURN + (AND (|bpPrimary|) (|bpAnyNo| #'|bpSelector|) + (OR (AND (|bpApplication|) + (|bpPush| (|bfApplication| (|bpPop2|) (|bpPop1|)))) + T))))) + +(DEFUN |bpTagged| () + (PROG () + (RETURN + (AND (|bpApplication|) + (OR (AND (|bpEqKey| 'COLON) + (OR (|bpApplication|) (|bpTrap|)) + (|bpPush| (|bfTagged| (|bpPop2|) (|bpPop1|)))) + T))))) + +(DEFUN |bpExpt| () + (PROG () (RETURN (|bpRightAssoc| '(POWER) #'|bpTagged|)))) + +(DEFUN |bpInfKey| (|s|) + (PROG () + (DECLARE (SPECIAL |$ttok| |$stok|)) + (RETURN + (AND (EQCAR |$stok| 'KEY) (MEMBER |$ttok| |s|) (|bpPushId|) + (|bpNext|))))) + +(DEFUN |bpInfGeneric| (|s|) + (PROG () + (RETURN (AND (|bpInfKey| |s|) (OR (|bpEqKey| 'BACKSET) T))))) + +(DEFUN |bpRightAssoc| (|o| |p|) + (PROG (|a|) + (RETURN + (PROGN + (SETQ |a| (|bpState|)) + (COND + ((APPLY |p| NIL) + (LOOP + (COND + ((NOT (AND (|bpInfGeneric| |o|) + (OR (|bpRightAssoc| |o| |p|) (|bpTrap|)))) + (RETURN NIL)) + ('T + (|bpPush| + (|bfInfApplication| (|bpPop2|) (|bpPop2|) + (|bpPop1|)))))) + T) + ('T (|bpRestore| |a|) NIL)))))) + +(DEFUN |bpLeftAssoc| (|operations| |parser|) + (PROG () + (RETURN + (COND + ((APPLY |parser| NIL) + (LOOP + (COND + ((NOT (AND (|bpInfGeneric| |operations|) + (OR (APPLY |parser| NIL) (|bpTrap|)))) + (RETURN NIL)) + ('T + (|bpPush| + (|bfInfApplication| (|bpPop2|) (|bpPop2|) (|bpPop1|)))))) + T) + ('T NIL))))) + +(DEFUN |bpString| () + (PROG () + (DECLARE (SPECIAL |$ttok| |$stok|)) + (RETURN + (AND (EQ (|shoeTokType| |$stok|) 'STRING) + (|bpPush| (LIST 'QUOTE (INTERN |$ttok|))) (|bpNext|))))) + +(DEFUN |bpThetaName| () + (PROG () + (DECLARE (SPECIAL |$ttok| |$stok|)) + (RETURN + (COND + ((AND (EQCAR |$stok| 'ID) (GET |$ttok| 'SHOETHETA)) + (|bpPushId|) (|bpNext|)) + ('T NIL))))) + +(DEFUN |bpReduceOperator| () + (PROG () + (RETURN (OR (|bpInfixOperator|) (|bpString|) (|bpThetaName|))))) + +(DEFUN |bpReduce| () + (PROG (|a|) + (RETURN + (PROGN + (SETQ |a| (|bpState|)) + (COND + ((AND (|bpReduceOperator|) (|bpEqKey| 'SLASH)) + (COND + ((|bpEqPeek| 'OBRACK) + (AND (OR (|bpDConstruct|) (|bpTrap|)) + (|bpPush| (|bfReduceCollect| (|bpPop2|) (|bpPop1|))))) + ('T + (AND (OR (|bpApplication|) (|bpTrap|)) + (|bpPush| (|bfReduce| (|bpPop2|) (|bpPop1|))))))) + ('T (|bpRestore| |a|) NIL)))))) + +(DEFUN |bpTimes| () + (PROG () + (RETURN + (OR (|bpReduce|) (|bpLeftAssoc| '(TIMES SLASH) #'|bpExpt|))))) + +(DEFUN |bpMinus| () + (PROG () + (RETURN + (OR (AND (|bpInfGeneric| '(MINUS)) (OR (|bpTimes|) (|bpTrap|)) + (|bpPush| (|bfApplication| (|bpPop2|) (|bpPop1|)))) + (|bpTimes|))))) + +(DEFUN |bpArith| () + (PROG () (RETURN (|bpLeftAssoc| '(PLUS MINUS) #'|bpMinus|)))) + +(DEFUN |bpIs| () + (PROG () + (RETURN + (AND (|bpArith|) + (OR (AND (|bpInfKey| '(IS ISNT)) + (OR (|bpPattern|) (|bpTrap|)) + (|bpPush| + (|bfISApplication| (|bpPop2|) (|bpPop2|) + (|bpPop1|)))) + T))))) + +(DEFUN |bpBracketConstruct| (|f|) + (PROG () + (RETURN + (AND (|bpBracket| |f|) (|bpPush| (|bfConstruct| (|bpPop1|))))))) + +(DEFUN |bpCompare| () + (PROG () + (RETURN + (AND (|bpIs|) + (OR (AND (|bpInfKey| '(SHOEEQ SHOENE LT LE GT GE IN)) + (OR (|bpIs|) (|bpTrap|)) + (|bpPush| + (|bfInfApplication| (|bpPop2|) (|bpPop2|) + (|bpPop1|)))) + T))))) + +(DEFUN |bpAnd| () + (PROG () (RETURN (|bpLeftAssoc| '(AND) #'|bpCompare|)))) + +(DEFUN |bpNoteReturnStmt| () + (PROG () + (DECLARE (SPECIAL |$bodyHasReturn|)) + (RETURN (PROGN (SETQ |$bodyHasReturn| T) T)))) + +(DEFUN |bpReturn| () + (PROG () + (RETURN + (OR (AND (|bpEqKey| 'RETURN) (|bpNoteReturnStmt|) + (OR (|bpAnd|) (|bpTrap|)) + (|bpPush| (|bfReturnNoName| (|bpPop1|)))) + (|bpAnd|))))) + +(DEFUN |bpLogical| () + (PROG () (RETURN (|bpLeftAssoc| '(OR) #'|bpReturn|)))) + +(DEFUN |bpExpression| () + (PROG () + (RETURN + (OR (AND (|bpEqKey| 'COLON) + (OR (AND (|bpLogical|) + (|bpPush| (|bfApplication| 'COLON (|bpPop1|)))) + (|bpTrap|))) + (|bpLogical|))))) + +(DEFUN |bpStatement| () + (PROG () + (RETURN + (OR (|bpConditional| #'|bpWhere|) (|bpLoop|) (|bpExpression|))))) + +(DEFUN |bpLoop| () + (PROG () + (RETURN + (OR (AND (|bpIterators|) (|bpCompMissing| 'REPEAT) + (OR (|bpWhere|) (|bpTrap|)) + (|bpPush| (|bfLp| (|bpPop2|) (|bpPop1|)))) + (AND (|bpEqKey| 'REPEAT) (OR (|bpLogical|) (|bpTrap|)) + (|bpPush| (|bfLoop1| (|bpPop1|)))))))) + +(DEFUN |bpSuchThat| () + (PROG () (RETURN (|bpAndOr| 'BAR #'|bpWhere| #'|bfSuchthat|)))) + +(DEFUN |bpWhile| () + (PROG () (RETURN (|bpAndOr| 'WHILE #'|bpLogical| #'|bfWhile|)))) + +(DEFUN |bpUntil| () + (PROG () (RETURN (|bpAndOr| 'UNTIL #'|bpLogical| #'|bfUntil|)))) + +(DEFUN |bpForIn| () + (PROG () + (RETURN + (AND (|bpEqKey| 'FOR) (OR (|bpVariable|) (|bpTrap|)) + (|bpCompMissing| 'IN) + (OR (AND (OR (|bpSeg|) (|bpTrap|)) (|bpEqKey| 'BY) + (OR (|bpArith|) (|bpTrap|)) + (|bpPush| + (|bfForInBy| (|bpPop3|) (|bpPop2|) (|bpPop1|)))) + (|bpPush| (|bfForin| (|bpPop2|) (|bpPop1|)))))))) + +(DEFUN |bpSeg| () + (PROG () + (RETURN + (AND (|bpArith|) + (OR (AND (|bpEqKey| 'SEG) + (OR (AND (|bpArith|) + (|bpPush| + (|bfSegment2| (|bpPop2|) (|bpPop1|)))) + (|bpPush| (|bfSegment1| (|bpPop1|))))) + T))))) + +(DEFUN |bpIterator| () + (PROG () + (RETURN (OR (|bpForIn|) (|bpSuchThat|) (|bpWhile|) (|bpUntil|))))) + +(DEFUN |bpIteratorList| () + (PROG () + (RETURN + (AND (|bpOneOrMore| #'|bpIterator|) + (|bpPush| (|bfIterators| (|bpPop1|))))))) + +(DEFUN |bpCrossBackSet| () + (PROG () + (RETURN (AND (|bpEqKey| 'CROSS) (OR (|bpEqKey| 'BACKSET) T))))) + +(DEFUN |bpIterators| () + (PROG () + (RETURN + (|bpListofFun| #'|bpIteratorList| #'|bpCrossBackSet| #'|bfCross|)))) + +(DEFUN |bpAssign| () + (PROG (|a|) + (RETURN + (PROGN + (SETQ |a| (|bpState|)) + (COND + ((|bpStatement|) + (COND + ((|bpEqPeek| 'BEC) (|bpRestore| |a|) + (OR (|bpAssignment|) (|bpTrap|))) + (#0='T T))) + (#0# (|bpRestore| |a|) NIL)))))) + +(DEFUN |bpAssignment| () + (PROG () + (RETURN + (AND (|bpAssignVariable|) (|bpEqKey| 'BEC) + (OR (|bpAssign|) (|bpTrap|)) + (|bpPush| (|bfAssign| (|bpPop2|) (|bpPop1|))))))) + +(DEFUN |bpExit| () + (PROG () + (RETURN + (AND (|bpAssign|) + (OR (AND (|bpEqKey| 'EXIT) (OR (|bpWhere|) (|bpTrap|)) + (|bpPush| (|bfExit| (|bpPop2|) (|bpPop1|)))) + T))))) + +(DEFUN |bpBeginDefinition| () + (PROG () + (DECLARE (SPECIAL |$sawParenthesizedHead|)) + (RETURN + (OR (|bpEqPeek| 'DEF) + (AND |$sawParenthesizedHead| (|bpEqPeek| 'COLON)))))) + +(DEFUN |bpDefinition| () + (PROG (|a|) + (RETURN + (PROGN + (SETQ |a| (|bpState|)) + (COND + ((|bpExit|) + (COND + ((|bpBeginDefinition|) + (PROGN (|bpRestore| |a|) (|bpDef|))) + ((|bpEqPeek| 'TDEF) + (PROGN (|bpRestore| |a|) (|bpTypeAliasDefition|))) + ((|bpEqPeek| 'MDEF) (PROGN (|bpRestore| |a|) (|bpMdef|))) + (#0='T T))) + (#0# (PROGN (|bpRestore| |a|) NIL))))))) + +(DEFUN |bpStoreName| () + (PROG () + (DECLARE (SPECIAL |$bodyHasReturn| |$returnType| |$typings| + |$wheredefs| |$op| |$stack|)) + (RETURN + (PROGN + (SETQ |$op| (CAR |$stack|)) + (SETQ |$wheredefs| NIL) + (SETQ |$typings| NIL) + (SETQ |$returnType| T) + (SETQ |$bodyHasReturn| NIL) + T)))) + +(DEFUN |bpReturnType| () + (PROG () + (DECLARE (SPECIAL |$returnType| |$sawParenthesizedHead|)) + (RETURN + (COND + ((AND |$sawParenthesizedHead| (|bpEqKey| 'COLON)) + (PROGN + (OR (|bpApplication|) (|bpTrap|)) + (SETQ |$returnType| (|bpPop1|)) + T)) + ('T T))))) + +(DEFUN |bpDef| () + (PROG () + (RETURN + (AND (|bpName|) (|bpStoreName|) (|bpDefTail|) + (|bpPush| (|bfCompDef| (|bpPop1|))))))) + +(DEFUN |bpDDef| () (PROG () (RETURN (AND (|bpName|) (|bpDefTail|))))) + +(DEFUN |bpSimpleDefinitionTail| () + (PROG () + (RETURN + (AND (|bpEqKey| 'DEF) (OR (|bpWhere|) (|bpTrap|)) + (|bpPush| (|ConstantDefinition| (|bpPop2|) (|bpPop1|))))))) + +(DEFUN |bpCompoundDefinitionTail| () + (PROG () + (RETURN + (AND (|bpVariable|) (|bpReturnType|) (|bpEqKey| 'DEF) + (OR (|bpWhere|) (|bpTrap|)) + (|bpPush| (|bfDefinition| (|bpPop3|) (|bpPop2|) (|bpPop1|))))))) + +(DEFUN |bpDefTail| () + (PROG () + (RETURN + (OR (|bpSimpleDefinitionTail|) (|bpCompoundDefinitionTail|))))) + +(DEFUN |bpMDefTail| () + (PROG () + (RETURN + (AND (OR (|bpVariable|) (|bpTrap|)) (|bpEqKey| 'MDEF) + (OR (|bpWhere|) (|bpTrap|)) + (|bpPush| + (|bfMDefinition| (|bpPop3|) (|bpPop2|) (|bpPop1|))))))) + +(DEFUN |bpMdef| () + (PROG () (RETURN (AND (|bpName|) (|bpStoreName|) (|bpMDefTail|))))) + +(DEFUN |bpWhere| () + (PROG () + (RETURN + (AND (|bpDefinition|) + (OR (AND (|bpEqKey| 'WHERE) + (OR (|bpDefinitionItem|) (|bpTrap|)) + (|bpPush| (|bfWhere| (|bpPop1|) (|bpPop1|)))) + T))))) + +(DEFUN |bpDefinitionItem| () + (PROG (|a|) + (RETURN + (PROGN + (SETQ |a| (|bpState|)) + (COND + ((|bpDDef|) T) + (#0='T (|bpRestore| |a|) + (COND + ((|bpBDefinitionPileItems|) T) + (#0# (|bpRestore| |a|) + (COND + ((|bpPDefinitionItems|) T) + (#0# (|bpRestore| |a|) (|bpWhere|))))))))))) + +(DEFUN |bpDefinitionPileItems| () + (PROG () + (RETURN + (AND (|bpListAndRecover| #'|bpDefinitionItem|) + (|bpPush| (|bfDefSequence| (|bpPop1|))))))) + +(DEFUN |bpBDefinitionPileItems| () + (PROG () (RETURN (|bpPileBracketed| #'|bpDefinitionPileItems|)))) + +(DEFUN |bpSemiColonDefinition| () + (PROG () + (RETURN (|bpSemiListing| #'|bpDefinitionItem| #'|bfDefSequence|)))) + +(DEFUN |bpPDefinitionItems| () + (PROG () (RETURN (|bpParenthesized| #'|bpSemiColonDefinition|)))) + +(DEFUN |bpComma| () + (PROG () + (RETURN (OR (|bpModule|) (|bpImport|) (|bpTuple| #'|bpWhere|))))) + +(DEFUN |bpTuple| (|p|) + (PROG () + (RETURN (|bpListofFun| |p| #'|bpCommaBackSet| #'|bfTuple|)))) + +(DEFUN |bpCommaBackSet| () + (PROG () + (RETURN (AND (|bpEqKey| 'COMMA) (OR (|bpEqKey| 'BACKSET) T))))) + +(DEFUN |bpSemiColon| () + (PROG () (RETURN (|bpSemiListing| #'|bpComma| #'|bfSequence|)))) + +(DEFUN |bpSemiListing| (|p| |f|) + (PROG () (RETURN (|bpListofFun| |p| #'|bpSemiBackSet| |f|)))) + +(DEFUN |bpSemiBackSet| () + (PROG () + (RETURN (AND (|bpEqKey| 'SEMICOLON) (OR (|bpEqKey| 'BACKSET) T))))) + +(DEFUN |bpPDefinition| () + (PROG () (RETURN (|bpIndentParenthesized| #'|bpSemiColon|)))) + +(DEFUN |bpPileItems| () + (PROG () + (RETURN + (AND (|bpListAndRecover| #'|bpSemiColon|) + (|bpPush| (|bfSequence| (|bpPop1|))))))) + +(DEFUN |bpBPileDefinition| () + (PROG () (RETURN (|bpPileBracketed| #'|bpPileItems|)))) + +(DEFUN |bpIteratorTail| () + (PROG () (RETURN (AND (OR (|bpEqKey| 'REPEAT) T) (|bpIterators|))))) + +(DEFUN |bpConstruct| () + (PROG () (RETURN (|bpBracket| #'|bpConstruction|)))) + +(DEFUN |bpConstruction| () + (PROG () + (RETURN + (AND (|bpComma|) + (OR (AND (|bpIteratorTail|) + (|bpPush| (|bfCollect| (|bpPop2|) (|bpPop1|)))) + (|bpPush| (|bfTupleConstruct| (|bpPop1|)))))))) + +(DEFUN |bpDConstruct| () + (PROG () (RETURN (|bpBracket| #'|bpDConstruction|)))) + +(DEFUN |bpDConstruction| () + (PROG () + (RETURN + (AND (|bpComma|) + (OR (AND (|bpIteratorTail|) + (|bpPush| (|bfDCollect| (|bpPop2|) (|bpPop1|)))) + (|bpPush| (|bfDTuple| (|bpPop1|)))))))) + +(DEFUN |bpPattern| () + (PROG () + (RETURN + (OR (|bpBracketConstruct| #'|bpPatternL|) (|bpName|) + (|bpConstTok|))))) + +(DEFUN |bpEqual| () + (PROG () + (RETURN + (AND (|bpEqKey| 'SHOEEQ) + (OR (|bpApplication|) (|bpConstTok|) (|bpTrap|)) + (|bpPush| (|bfEqual| (|bpPop1|))))))) + +(DEFUN |bpRegularPatternItem| () + (PROG () + (RETURN + (OR (|bpEqual|) (|bpConstTok|) (|bpDot|) + (AND (|bpName|) + (OR (AND (|bpEqKey| 'BEC) (OR (|bpPattern|) (|bpTrap|)) + (|bpPush| (|bfAssign| (|bpPop2|) (|bpPop1|)))) + T)) + (|bpBracketConstruct| #'|bpPatternL|))))) + +(DEFUN |bpRegularPatternItemL| () + (PROG () + (RETURN + (AND (|bpRegularPatternItem|) (|bpPush| (LIST (|bpPop1|))))))) + +(DEFUN |bpRegularList| () + (PROG () + (RETURN + (|bpListof| #'|bpRegularPatternItemL| 'COMMA #'|bfAppend|)))) + +(DEFUN |bpPatternColon| () + (PROG () + (RETURN + (AND (|bpEqKey| 'COLON) (OR (|bpRegularPatternItem|) (|bpTrap|)) + (|bpPush| (LIST (|bfColon| (|bpPop1|)))))))) + +(DEFUN |bpPatternL| () + (PROG () + (RETURN (AND (|bpPatternList|) (|bpPush| (|bfTuple| (|bpPop1|))))))) + +(DEFUN |bpPatternList| () + (PROG () + (RETURN + (COND + ((|bpRegularPatternItemL|) + (LOOP + (COND + ((NOT (AND (|bpEqKey| 'COMMA) + (OR (|bpRegularPatternItemL|) + (PROGN + (OR (AND (|bpPatternTail|) + (|bpPush| + (APPEND (|bpPop2|) (|bpPop1|)))) + (|bpTrap|)) + NIL)))) + (RETURN NIL)) + ('T (|bpPush| (APPEND (|bpPop2|) (|bpPop1|)))))) + T) + ('T (|bpPatternTail|)))))) + +(DEFUN |bpPatternTail| () + (PROG () + (RETURN + (AND (|bpPatternColon|) + (OR (AND (|bpEqKey| 'COMMA) + (OR (|bpRegularList|) (|bpTrap|)) + (|bpPush| (APPEND (|bpPop2|) (|bpPop1|)))) + T))))) + +(DEFUN |bpRegularBVItem| () + (PROG () + (RETURN + (OR (|bpBVString|) (|bpConstTok|) + (AND (|bpName|) + (OR (AND (|bpEqKey| 'COLON) + (OR (|bpApplication|) (|bpTrap|)) + (|bpPush| (|bfTagged| (|bpPop2|) (|bpPop1|)))) + (AND (|bpEqKey| 'BEC) (OR (|bpPattern|) (|bpTrap|)) + (|bpPush| (|bfAssign| (|bpPop2|) (|bpPop1|)))) + (AND (|bpEqKey| 'IS) (OR (|bpPattern|) (|bpTrap|)) + (|bpPush| (|bfAssign| (|bpPop2|) (|bpPop1|)))) + T)) + (|bpBracketConstruct| #'|bpPatternL|))))) + +(DEFUN |bpBVString| () + (PROG () + (DECLARE (SPECIAL |$ttok| |$stok|)) + (RETURN + (AND (EQ (|shoeTokType| |$stok|) 'STRING) + (|bpPush| (LIST 'BVQUOTE (INTERN |$ttok|))) (|bpNext|))))) + +(DEFUN |bpRegularBVItemL| () + (PROG () + (RETURN (AND (|bpRegularBVItem|) (|bpPush| (LIST (|bpPop1|))))))) + +(DEFUN |bpColonName| () + (PROG () + (RETURN + (AND (|bpEqKey| 'COLON) + (OR (|bpName|) (|bpBVString|) (|bpTrap|)))))) + +(DEFUN |bpBoundVariablelist| () + (PROG () + (RETURN + (COND + ((|bpRegularBVItemL|) + (LOOP + (COND + ((NOT (AND (|bpEqKey| 'COMMA) + (OR (|bpRegularBVItemL|) + (PROGN + (OR (AND (|bpColonName|) + (|bpPush| + (|bfColonAppend| (|bpPop2|) + (|bpPop1|)))) + (|bpTrap|)) + NIL)))) + (RETURN NIL)) + ('T (|bpPush| (APPEND (|bpPop2|) (|bpPop1|)))))) + T) + ('T + (AND (|bpColonName|) + (|bpPush| (|bfColonAppend| NIL (|bpPop1|))))))))) + +(DEFUN |bpBeginParameterList| () + (PROG () + (DECLARE (SPECIAL |$sawParenthesizedHead|)) + (RETURN (PROGN (SETQ |$sawParenthesizedHead| NIL) T)))) + +(DEFUN |bpEndParameterList| () + (PROG () + (DECLARE (SPECIAL |$sawParenthesizedHead|)) + (RETURN (SETQ |$sawParenthesizedHead| T)))) + +(DEFUN |bpVariable| () + (PROG () + (RETURN + (OR (AND (|bpBeginParameterList|) + (|bpParenthesized| #'|bpBoundVariablelist|) + (|bpPush| (|bfTupleIf| (|bpPop1|))) + (|bpEndParameterList|)) + (|bpBracketConstruct| #'|bpPatternL|) (|bpName|) + (|bpConstTok|))))) + +(DEFUN |bpAssignVariable| () + (PROG () + (RETURN + (OR (|bpBracketConstruct| #'|bpPatternL|) (|bpAssignLHS|))))) + +(DEFUN |bpAssignLHS| () + (PROG () + (RETURN + (AND (|bpName|) + (OR (AND (|bpEqKey| 'COLON) + (OR (|bpApplication|) (|bpTrap|)) + (|bpPush| (|bfLocal| (|bpPop2|) (|bpPop1|)))) + (AND (|bpEqKey| 'DOT) + (|bpList| #'|bpPrimary| 'DOT #'|bfListOf|) + (|bpChecknull|) + (|bpPush| (|bfTuple| (CONS (|bpPop2|) (|bpPop1|))))) + T))))) + +(DEFUN |bpChecknull| () + (PROG (|a|) + (RETURN + (PROGN + (SETQ |a| (|bpPop1|)) + (COND ((NULL |a|) (|bpTrap|)) ('T (|bpPush| |a|))))))) + +(DEFUN |bpStruct| () + (PROG () + (RETURN + (AND (|bpEqKey| 'STRUCTURE) (OR (|bpName|) (|bpTrap|)) + (OR (|bpEqKey| 'DEF) (|bpTrap|)) (|bpTypeList|) + (|bpPush| (|bfStruct| (|bpPop2|) (|bpPop1|))))))) + +(DEFUN |bpTypeList| () + (PROG () + (RETURN + (OR (|bpPileBracketed| #'|bpTypeItemList|) + (AND (|bpTerm|) (|bpPush| (LIST (|bpPop1|)))))))) + +(DEFUN |bpTypeItemList| () + (PROG () (RETURN (|bpListAndRecover| #'|bpTerm|)))) + +(DEFUN |bpTerm| () + (PROG () + (RETURN + (OR (AND (OR (|bpName|) (|bpTrap|)) + (OR (AND (|bpParenthesized| #'|bpIdList|) + (|bpPush| (|bfNameArgs| (|bpPop2|) (|bpPop1|)))) + (AND (|bpName|) + (|bpPush| (|bfNameArgs| (|bpPop2|) (|bpPop1|)))))) + (|bpPush| (|bfNameOnly| (|bpPop1|))))))) + +(DEFUN |bpIdList| () (PROG () (RETURN (|bpTuple| #'|bpName|)))) + +(DEFUN |bpCase| () + (PROG () + (RETURN + (AND (|bpEqKey| 'CASE) (OR (|bpWhere|) (|bpTrap|)) + (OR (|bpEqKey| 'OF) (|bpMissing| 'OF)) (|bpPiledCaseItems|))))) + +(DEFUN |bpPiledCaseItems| () + (PROG () + (RETURN + (AND (|bpPileBracketed| #'|bpCaseItemList|) + (|bpPush| (|bfCase| (|bpPop2|) (|bpPop1|))))))) + +(DEFUN |bpCaseItemList| () + (PROG () (RETURN (|bpListAndRecover| #'|bpCaseItem|)))) + +(DEFUN |bpCaseItem| () + (PROG () + (RETURN + (AND (OR (|bpTerm|) (|bpTrap|)) (OR (|bpEqKey| 'EXIT) (|bpTrap|)) + (OR (|bpWhere|) (|bpTrap|)) + (|bpPush| (|bfCaseItem| (|bpPop2|) (|bpPop1|))))))) + |