* boot/parser.boot (bpRequire): New. Use it throughout this module.

1 files changed, 74 insertions, 84 deletions

diff --git a/src/boot/strap/parser.clisp b/src/boot/strap/parser.clisp
index f8417b34..34fff72f 100644
--- a/src/boot/strap/parser.clisp
+++ b/src/boot/strap/parser.clisp
@@ -45,6 +45,8 @@
   (DECLARE (SPECIAL |$inputStream|))
   (PROGN (SETQ |$inputStream| (CDR |$inputStream|)) (|bpFirstToken|)))
 
+(DEFUN |bpRequire| (|f|) (OR (APPLY |f| NIL) (|bpTrap|)))
+
 (DEFUN |bpState| ()
   (DECLARE (SPECIAL |$inputStream| |$stack| |$bpParenCount| |$bpCount|))
   (LIST |$inputStream| |$stack| |$bpParenCount| |$bpCount|))
@@ -157,13 +159,11 @@
      (COND
       ((APPLY |f| NIL)
        (COND
-        ((AND (|bpEqKey| |str1|) (OR (APPLY |f| NIL) (|bpTrap|)))
-         (SETQ |a| |$stack|) (SETQ |$stack| NIL)
+        ((AND (|bpEqKey| |str1|) (|bpRequire| |f|)) (SETQ |a| |$stack|)
+         (SETQ |$stack| NIL)
          (LOOP
-          (COND
-           ((NOT (AND (|bpEqKey| |str1|) (OR (APPLY |f| NIL) (|bpTrap|))))
-            (RETURN NIL))
-           (T 0)))
+          (COND ((NOT (AND (|bpEqKey| |str1|) (|bpRequire| |f|))) (RETURN NIL))
+                (T 0)))
          (SETQ |$stack| (CONS (|reverse!| |$stack|) |a|))
          (|bpPush|
           (FUNCALL |g| (CONS (|bpPop3|) (CONS (|bpPop2|) (|bpPop1|))))))
@@ -177,13 +177,11 @@
      (COND
       ((APPLY |f| NIL)
        (COND
-        ((AND (APPLY |h| NIL) (OR (APPLY |f| NIL) (|bpTrap|)))
-         (SETQ |a| |$stack|) (SETQ |$stack| NIL)
+        ((AND (APPLY |h| NIL) (|bpRequire| |f|)) (SETQ |a| |$stack|)
+         (SETQ |$stack| NIL)
          (LOOP
-          (COND
-           ((NOT (AND (APPLY |h| NIL) (OR (APPLY |f| NIL) (|bpTrap|))))
-            (RETURN NIL))
-           (T 0)))
+          (COND ((NOT (AND (APPLY |h| NIL) (|bpRequire| |f|))) (RETURN NIL))
+                (T 0)))
          (SETQ |$stack| (CONS (|reverse!| |$stack|) |a|))
          (|bpPush|
           (FUNCALL |g| (CONS (|bpPop3|) (CONS (|bpPop2|) (|bpPop1|))))))
@@ -197,13 +195,11 @@
      (COND
       ((APPLY |f| NIL)
        (COND
-        ((AND (|bpEqKey| |str1|) (OR (APPLY |f| NIL) (|bpTrap|)))
-         (SETQ |a| |$stack|) (SETQ |$stack| NIL)
+        ((AND (|bpEqKey| |str1|) (|bpRequire| |f|)) (SETQ |a| |$stack|)
+         (SETQ |$stack| NIL)
          (LOOP
-          (COND
-           ((NOT (AND (|bpEqKey| |str1|) (OR (APPLY |f| NIL) (|bpTrap|))))
-            (RETURN NIL))
-           (T 0)))
+          (COND ((NOT (AND (|bpEqKey| |str1|) (|bpRequire| |f|))) (RETURN NIL))
+                (T 0)))
          (SETQ |$stack| (CONS (|reverse!| |$stack|) |a|))
          (|bpPush| (CONS (|bpPop3|) (CONS (|bpPop2|) (|bpPop1|)))))
         (T (|bpPush| (LIST (|bpPop1|))))))
@@ -224,21 +220,19 @@
   (PROGN (LOOP (COND ((NOT (APPLY |s| NIL)) (RETURN NIL)) (T 0))) T))
 
 (DEFUN |bpAndOr| (|keyword| |p| |f|)
-  (AND (|bpEqKey| |keyword|) (OR (APPLY |p| NIL) (|bpTrap|))
+  (AND (|bpEqKey| |keyword|) (|bpRequire| |p|)
        (|bpPush| (FUNCALL |f| (|bpPop1|)))))
 
 (DEFUN |bpConditional| (|f|)
   (COND
-   ((AND (|bpEqKey| 'IF) (OR (|bpWhere|) (|bpTrap|))
-         (OR (|bpEqKey| 'BACKSET) T))
+   ((AND (|bpEqKey| 'IF) (|bpRequire| #'|bpWhere|) (OR (|bpEqKey| 'BACKSET) T))
     (COND
      ((|bpEqKey| 'SETTAB)
       (COND
        ((|bpEqKey| 'THEN)
-        (AND (OR (APPLY |f| NIL) (|bpTrap|)) (|bpElse| |f|)
-             (|bpEqKey| 'BACKTAB)))
+        (AND (|bpRequire| |f|) (|bpElse| |f|) (|bpEqKey| 'BACKTAB)))
        (T (|bpMissing| 'THEN))))
-     ((|bpEqKey| 'THEN) (AND (OR (APPLY |f| NIL) (|bpTrap|)) (|bpElse| |f|)))
+     ((|bpEqKey| 'THEN) (AND (|bpRequire| |f|) (|bpElse| |f|)))
      (T (|bpMissing| '|then|))))
    (T NIL)))
 
@@ -249,7 +243,7 @@
       (SETQ |a| (|bpState|))
       (COND
        ((|bpBacksetElse|)
-        (AND (OR (APPLY |f| NIL) (|bpTrap|))
+        (AND (|bpRequire| |f|)
              (|bpPush| (|bfIf| (|bpPop3|) (|bpPop2|) (|bpPop1|)))))
        (T (|bpRestore| |a|)
         (|bpPush| (|bfIfThenOnly| (|bpPop2|) (|bpPop1|)))))))))
@@ -393,7 +387,7 @@
    ((AND (CONSP |$stok|) (EQ (CAR |$stok|) 'LINE))
     (AND (|bpPush| (LIST '+LINE |$ttok|)) (|bpNext|)))
    ((|bpEqPeek| 'QUOTE) (|bpNext|)
-    (AND (OR (|bpSexp|) (|bpTrap|)) (|bpPush| (|bfSymbol| (|bpPop1|)))))
+    (AND (|bpRequire| #'|bpSexp|) (|bpPush| (|bfSymbol| (|bpPop1|)))))
    (T (|bpString|))))
 
 (DEFUN |bpChar| ()
@@ -417,7 +411,7 @@
 
 (DEFUN |bpExportItemTail| ()
   (OR
-   (AND (|bpEqKey| 'BEC) (OR (|bpAssign|) (|bpTrap|))
+   (AND (|bpEqKey| 'BEC) (|bpRequire| #'|bpAssign|)
         (|bpPush| (|%Assignment| (|bpPop2|) (|bpPop1|))))
    (|bpSimpleDefinitionTail|)))
 
@@ -430,7 +424,7 @@
              ((|bpName|)
               (COND
                ((|bpEqPeek| 'COLON) (|bpRestore| |a|)
-                (OR (|bpSignature|) (|bpTrap|)) (OR (|bpExportItemTail|) T))
+                (|bpRequire| #'|bpSignature|) (OR (|bpExportItemTail|) T))
                (T (|bpRestore| |a|) (|bpTypeAliasDefition|))))
              (T NIL)))))))
 
@@ -449,7 +443,7 @@
 
 (DEFUN |bpModule| ()
   (COND
-   ((|bpEqKey| 'MODULE) (OR (|bpName|) (|bpTrap|)) (|bpModuleExports|)
+   ((|bpEqKey| 'MODULE) (|bpRequire| #'|bpName|) (|bpModuleExports|)
     (|bpModuleInterface|)
     (|bpPush| (|%Module| (|bpPop3|) (|bpPop2|) (|bpPop1|))))
    (T NIL)))
@@ -465,11 +459,11 @@
           (AND (|bpLeftAssoc| '(DOT) #'|bpName|)
                (|bpPush| (|%Import| (|bfNamespace| (|bpPop1|)))))
           (|bpTrap|)))
-        (T (SETQ |a| (|bpState|)) (OR (|bpName|) (|bpTrap|))
+        (T (SETQ |a| (|bpState|)) (|bpRequire| #'|bpName|)
          (COND
           ((|bpEqPeek| 'COLON) (|bpRestore| |a|)
-           (AND (OR (|bpSignature|) (|bpTrap|))
-                (OR (|bpEqKey| 'FOR) (|bpTrap|)) (OR (|bpName|) (|bpTrap|))
+           (AND (|bpRequire| #'|bpSignature|) (OR (|bpEqKey| 'FOR) (|bpTrap|))
+                (|bpRequire| #'|bpName|)
                 (|bpPush| (|%ImportSignature| (|bpPop1|) (|bpPop1|)))))
           (T (|bpPush| (|%Import| (|bpPop1|))))))))
       (T NIL)))))
@@ -489,7 +483,7 @@
 (DEFUN |bpSimpleMapping| ()
   (COND
    ((|bpApplication|)
-    (AND (|bpEqKey| 'ARROW) (OR (|bpApplication|) (|bpTrap|))
+    (AND (|bpEqKey| 'ARROW) (|bpRequire| #'|bpApplication|)
          (|bpPush| (|%Mapping| (|bpPop1|) (LIST (|bpPop1|)))))
     T)
    (T NIL)))
@@ -552,7 +546,7 @@
 
 (DEFUN |bpSexp| ()
   (OR (|bpAnyId|)
-      (AND (|bpEqKey| 'QUOTE) (OR (|bpSexp|) (|bpTrap|))
+      (AND (|bpEqKey| 'QUOTE) (|bpRequire| #'|bpSexp|)
            (|bpPush| (|bfSymbol| (|bpPop1|))))
       (|bpIndentParenthesized| #'|bpSexp1|)))
 
@@ -606,15 +600,15 @@
 
 (DEFUN |bpTyping| ()
   (COND
-   ((|bpEqKey| 'FORALL) (OR (|bpVariable|) (|bpTrap|))
-    (OR (AND (|bpDot|) (|bpPop1|)) (|bpTrap|)) (OR (|bpTyping|) (|bpTrap|))
+   ((|bpEqKey| 'FORALL) (|bpRequire| #'|bpVariable|)
+    (OR (AND (|bpDot|) (|bpPop1|)) (|bpTrap|)) (|bpRequire| #'|bpTyping|)
     (|bpPush| (|%Forall| (|bpPop2|) (|bpPop1|))))
    (T (OR (|bpMapping|) (|bpSimpleMapping|)))))
 
 (DEFUN |bpTagged| ()
   (AND (|bpApplication|)
        (OR
-        (AND (|bpEqKey| 'COLON) (OR (|bpTyping|) (|bpTrap|))
+        (AND (|bpEqKey| 'COLON) (|bpRequire| #'|bpTyping|)
              (|bpPush| (|bfTagged| (|bpPop2|) (|bpPop1|))))
         T)))
 
@@ -650,9 +644,7 @@
    ((APPLY |parser| NIL)
     (LOOP
      (COND
-      ((NOT
-        (AND (|bpInfGeneric| |operations|)
-             (OR (APPLY |parser| NIL) (|bpTrap|))))
+      ((NOT (AND (|bpInfGeneric| |operations|) (|bpRequire| |parser|)))
        (RETURN NIL))
       (T (|bpPush| (|bfInfApplication| (|bpPop2|) (|bpPop2|) (|bpPop1|))))))
     T)
@@ -682,10 +674,10 @@
        ((AND (|bpReduceOperator|) (|bpEqKey| 'SLASH))
         (COND
          ((|bpEqPeek| 'OBRACK)
-          (AND (OR (|bpDConstruct|) (|bpTrap|))
+          (AND (|bpRequire| #'|bpDConstruct|)
                (|bpPush| (|bfReduceCollect| (|bpPop2|) (|bpPop1|)))))
          (T
-          (AND (OR (|bpApplication|) (|bpTrap|))
+          (AND (|bpRequire| #'|bpApplication|)
                (|bpPush| (|bfReduce| (|bpPop2|) (|bpPop1|)))))))
        (T (|bpRestore| |a|) NIL))))))
 
@@ -695,7 +687,7 @@
 
 (DEFUN |bpMinus| ()
   (OR
-   (AND (|bpInfGeneric| '(MINUS)) (OR (|bpEuclid|) (|bpTrap|))
+   (AND (|bpInfGeneric| '(MINUS)) (|bpRequire| #'|bpEuclid|)
         (|bpPush| (|bfApplication| (|bpPop2|) (|bpPop1|))))
    (|bpEuclid|)))
 
@@ -704,9 +696,9 @@
 (DEFUN |bpIs| ()
   (AND (|bpArith|)
        (COND
-        ((AND (|bpInfKey| '(IS ISNT)) (OR (|bpPattern|) (|bpTrap|)))
+        ((AND (|bpInfKey| '(IS ISNT)) (|bpRequire| #'|bpPattern|))
          (|bpPush| (|bfISApplication| (|bpPop2|) (|bpPop2|) (|bpPop1|))))
-        ((AND (|bpEqKey| 'HAS) (OR (|bpApplication|) (|bpTrap|)))
+        ((AND (|bpEqKey| 'HAS) (|bpRequire| #'|bpApplication|))
          (|bpPush| (|bfHas| (|bpPop2|) (|bpPop1|))))
         (T T))))
 
@@ -718,7 +710,7 @@
    (AND (|bpIs|)
         (OR
          (AND (|bpInfKey| '(SHOEEQ SHOENE LT LE GT GE IN))
-              (OR (|bpIs|) (|bpTrap|))
+              (|bpRequire| #'|bpIs|)
               (|bpPush| (|bfInfApplication| (|bpPop2|) (|bpPop2|) (|bpPop1|))))
          T))
    (|bpLeave|) (|bpThrow|)))
@@ -729,7 +721,7 @@
   (COND
    ((AND (|bpEqKey| 'THROW) (|bpApplication|))
     (COND
-     ((|bpEqKey| 'COLON) (OR (|bpApplication|) (|bpTrap|))
+     ((|bpEqKey| 'COLON) (|bpRequire| #'|bpApplication|)
       (|bpPush| (|%Pretend| (|bpPop2|) (|bpPop1|)))))
     (|bpPush| (|bfThrow| (|bpPop1|))))
    (T NIL)))
@@ -752,9 +744,8 @@
       (T NIL)))))
 
 (DEFUN |bpCatchItem| ()
-  (AND (OR (|bpExceptionVariable|) (|bpTrap|))
-       (OR (|bpEqKey| 'EXIT) (|bpTrap|)) (OR (|bpAssign|) (|bpTrap|))
-       (|bpPush| (|%Catch| (|bpPop2|) (|bpPop1|)))))
+  (AND (|bpRequire| #'|bpExceptionVariable|) (OR (|bpEqKey| 'EXIT) (|bpTrap|))
+       (|bpRequire| #'|bpAssign|) (|bpPush| (|%Catch| (|bpPop2|) (|bpPop1|)))))
 
 (DEFUN |bpExceptionVariable| ()
   (PROG (|t|)
@@ -763,12 +754,12 @@
      (PROGN
       (SETQ |t| |$stok|)
       (OR
-       (AND (|bpEqKey| 'OPAREN) (OR (|bpSignature|) (|bpTrap|))
+       (AND (|bpEqKey| 'OPAREN) (|bpRequire| #'|bpSignature|)
             (OR (|bpEqKey| 'CPAREN) (|bpMissing| |t|)))
        (|bpTrap|))))))
 
 (DEFUN |bpFinally| ()
-  (AND (OR (|bpAssign|) (|bpTrap|)) (|bpPush| (|%Finally| (|bpPop1|)))))
+  (AND (|bpRequire| #'|bpAssign|) (|bpPush| (|%Finally| (|bpPop1|)))))
 
 (DEFUN |bpHandler| (|key|)
   (PROG (|s|)
@@ -782,20 +773,20 @@
        (T (|bpRestore| |s|) NIL))))))
 
 (DEFUN |bpLeave| ()
-  (AND (|bpEqKey| 'LEAVE) (OR (|bpLogical|) (|bpTrap|))
+  (AND (|bpEqKey| 'LEAVE) (|bpRequire| #'|bpLogical|)
        (|bpPush| (|bfLeave| (|bpPop1|)))))
 
 (DEFUN |bpDo| ()
   (COND
-   ((|bpEqKey| 'IN) (OR (|bpNamespace|) (|bpTrap|)) (OR (|bpDo|) (|bpTrap|))
+   ((|bpEqKey| 'IN) (|bpRequire| #'|bpNamespace|) (|bpRequire| #'|bpDo|)
     (|bpPush| (|bfAtScope| (|bpPop2|) (|bpPop1|))))
    (T
-    (AND (|bpEqKey| 'DO) (OR (|bpAssign|) (|bpTrap|))
+    (AND (|bpEqKey| 'DO) (|bpRequire| #'|bpAssign|)
          (|bpPush| (|bfDo| (|bpPop1|)))))))
 
 (DEFUN |bpReturn| ()
   (OR
-   (AND (|bpEqKey| 'RETURN) (OR (|bpAssign|) (|bpTrap|))
+   (AND (|bpEqKey| 'RETURN) (|bpRequire| #'|bpAssign|)
         (|bpPush| (|bfReturnNoName| (|bpPop1|))))
    (|bpLeave|) (|bpThrow|) (|bpAnd|) (|bpDo|)))
 
@@ -813,9 +804,9 @@
 
 (DEFUN |bpLoop| ()
   (OR
-   (AND (|bpIterators|) (|bpCompMissing| 'REPEAT) (OR (|bpWhere|) (|bpTrap|))
+   (AND (|bpIterators|) (|bpCompMissing| 'REPEAT) (|bpRequire| #'|bpWhere|)
         (|bpPush| (|bfLp| (|bpPop2|) (|bpPop1|))))
-   (AND (|bpEqKey| 'REPEAT) (OR (|bpLogical|) (|bpTrap|))
+   (AND (|bpEqKey| 'REPEAT) (|bpRequire| #'|bpLogical|)
         (|bpPush| (|bfLoop1| (|bpPop1|))))))
 
 (DEFUN |bpSuchThat| () (|bpAndOr| 'BAR #'|bpWhere| #'|bfSuchthat|))
@@ -827,10 +818,9 @@
 (DEFUN |bpFormal| () (OR (|bpVariable|) (|bpDot|)))
 
 (DEFUN |bpForIn| ()
-  (AND (|bpEqKey| 'FOR) (OR (|bpFormal|) (|bpTrap|)) (|bpCompMissing| 'IN)
+  (AND (|bpEqKey| 'FOR) (|bpRequire| #'|bpFormal|) (|bpCompMissing| 'IN)
        (OR
-        (AND (OR (|bpSeg|) (|bpTrap|)) (|bpEqKey| 'BY)
-             (OR (|bpArith|) (|bpTrap|))
+        (AND (|bpRequire| #'|bpSeg|) (|bpEqKey| 'BY) (|bpRequire| #'|bpArith|)
              (|bpPush| (|bfForInBy| (|bpPop3|) (|bpPop2|) (|bpPop1|))))
         (|bpPush| (|bfForin| (|bpPop2|) (|bpPop1|))))))
 
@@ -861,18 +851,18 @@
       (COND
        ((|bpStatement|)
         (COND
-         ((|bpEqPeek| 'BEC) (|bpRestore| |a|) (OR (|bpAssignment|) (|bpTrap|)))
-         ((|bpEqPeek| 'GIVES) (|bpRestore| |a|) (OR (|bpLambda|) (|bpTrap|)))
-         ((|bpEqPeek| 'LARROW) (|bpRestore| |a|) (OR (|bpKeyArg|) (|bpTrap|)))
+         ((|bpEqPeek| 'BEC) (|bpRestore| |a|) (|bpRequire| #'|bpAssignment|))
+         ((|bpEqPeek| 'GIVES) (|bpRestore| |a|) (|bpRequire| #'|bpLambda|))
+         ((|bpEqPeek| 'LARROW) (|bpRestore| |a|) (|bpRequire| #'|bpKeyArg|))
          (T T)))
        (T (|bpRestore| |a|) NIL))))))
 
 (DEFUN |bpAssignment| ()
-  (AND (|bpAssignVariable|) (|bpEqKey| 'BEC) (OR (|bpAssign|) (|bpTrap|))
+  (AND (|bpAssignVariable|) (|bpEqKey| 'BEC) (|bpRequire| #'|bpAssign|)
        (|bpPush| (|bfAssign| (|bpPop2|) (|bpPop1|)))))
 
 (DEFUN |bpLambda| ()
-  (AND (|bpVariable|) (|bpEqKey| 'GIVES) (OR (|bpAssign|) (|bpTrap|))
+  (AND (|bpVariable|) (|bpEqKey| 'GIVES) (|bpRequire| #'|bpAssign|)
        (|bpPush| (|bfLambda| (|bpPop2|) (|bpPop1|)))))
 
 (DEFUN |bpKeyArg| ()
@@ -882,7 +872,7 @@
 (DEFUN |bpExit| ()
   (AND (|bpAssign|)
        (OR
-        (AND (|bpEqKey| 'EXIT) (OR (|bpWhere|) (|bpTrap|))
+        (AND (|bpEqKey| 'EXIT) (|bpRequire| #'|bpWhere|)
              (|bpPush| (|bfExit| (|bpPop2|) (|bpPop1|))))
         T)))
 
@@ -918,11 +908,11 @@
 (DEFUN |bpDDef| () (AND (|bpName|) (|bpDefTail| #'|%Definition|)))
 
 (DEFUN |bpSimpleDefinitionTail| ()
-  (AND (|bpEqKey| 'DEF) (OR (|bpWhere|) (|bpTrap|))
+  (AND (|bpEqKey| 'DEF) (|bpRequire| #'|bpWhere|)
        (|bpPush| (|%ConstantDefinition| (|bpPop2|) (|bpPop1|)))))
 
 (DEFUN |bpCompoundDefinitionTail| (|f|)
-  (AND (|bpVariable|) (|bpEqKey| 'DEF) (OR (|bpWhere|) (|bpTrap|))
+  (AND (|bpVariable|) (|bpEqKey| 'DEF) (|bpRequire| #'|bpWhere|)
        (|bpPush| (APPLY |f| (LIST (|bpPop3|) (|bpPop2|) (|bpPop1|))))))
 
 (DEFUN |bpDefTail| (|f|)
@@ -931,7 +921,7 @@
 (DEFUN |bpWhere| ()
   (AND (|bpDefinition|)
        (OR
-        (AND (|bpEqKey| 'WHERE) (OR (|bpDefinitionItem|) (|bpTrap|))
+        (AND (|bpEqKey| 'WHERE) (|bpRequire| #'|bpDefinitionItem|)
              (|bpPush| (|bfWhere| (|bpPop1|) (|bpPop1|))))
         T)))
 
@@ -1011,7 +1001,7 @@
   (OR (|bpEqual|) (|bpConstTok|) (|bpDot|)
       (AND (|bpName|)
            (OR
-            (AND (|bpEqKey| 'BEC) (OR (|bpPattern|) (|bpTrap|))
+            (AND (|bpEqKey| 'BEC) (|bpRequire| #'|bpPattern|)
                  (|bpPush| (|bfAssign| (|bpPop2|) (|bpPop1|))))
             T))
       (|bpBracketConstruct| #'|bpPatternL|)))
@@ -1023,7 +1013,7 @@
   (|bpListof| #'|bpRegularPatternItemL| 'COMMA #'|bfAppend|))
 
 (DEFUN |bpPatternColon| ()
-  (AND (|bpEqKey| 'COLON) (OR (|bpRegularPatternItem|) (|bpTrap|))
+  (AND (|bpEqKey| 'COLON) (|bpRequire| #'|bpRegularPatternItem|)
        (|bpPush| (LIST (|bfColon| (|bpPop1|))))))
 
 (DEFUN |bpPatternL| ()
@@ -1051,19 +1041,19 @@
 (DEFUN |bpPatternTail| ()
   (AND (|bpPatternColon|)
        (OR
-        (AND (|bpEqKey| 'COMMA) (OR (|bpRegularList|) (|bpTrap|))
+        (AND (|bpEqKey| 'COMMA) (|bpRequire| #'|bpRegularList|)
              (|bpPush| (|append| (|bpPop2|) (|bpPop1|))))
         T)))
 
 (DEFUN |bpRegularBVItemTail| ()
   (OR
-   (AND (|bpEqKey| 'COLON) (OR (|bpApplication|) (|bpTrap|))
+   (AND (|bpEqKey| 'COLON) (|bpRequire| #'|bpApplication|)
         (|bpPush| (|bfTagged| (|bpPop2|) (|bpPop1|))))
-   (AND (|bpEqKey| 'BEC) (OR (|bpPattern|) (|bpTrap|))
+   (AND (|bpEqKey| 'BEC) (|bpRequire| #'|bpPattern|)
         (|bpPush| (|bfAssign| (|bpPop2|) (|bpPop1|))))
-   (AND (|bpEqKey| 'IS) (OR (|bpPattern|) (|bpTrap|))
+   (AND (|bpEqKey| 'IS) (|bpRequire| #'|bpPattern|)
         (|bpPush| (|bfAssign| (|bpPop2|) (|bpPop1|))))
-   (AND (|bpEqKey| 'DEF) (OR (|bpApplication|) (|bpTrap|))
+   (AND (|bpEqKey| 'DEF) (|bpRequire| #'|bpApplication|)
         (|bpPush| (|%DefaultValue| (|bpPop2|) (|bpPop1|))))))
 
 (DEFUN |bpRegularBVItem| ()
@@ -1112,7 +1102,7 @@
 
 (DEFUN |bpAssignLHS| ()
   (COND ((NOT (|bpName|)) NIL)
-        ((|bpEqKey| 'COLON) (OR (|bpApplication|) (|bpTrap|))
+        ((|bpEqKey| 'COLON) (|bpRequire| #'|bpApplication|)
          (|bpPush| (|bfLocal| (|bpPop2|) (|bpPop1|))))
         (T
          (AND (|bpArgumentList|)
@@ -1133,13 +1123,13 @@
       (COND ((NULL |a|) (|bpTrap|)) (T (|bpPush| |a|)))))))
 
 (DEFUN |bpStruct| ()
-  (AND (|bpEqKey| 'STRUCTURE) (OR (|bpName|) (|bpTrap|))
+  (AND (|bpEqKey| 'STRUCTURE) (|bpRequire| #'|bpName|)
        (OR (|bpEqKey| 'DEF) (|bpTrap|)) (|bpTypeList|)
        (|bpPush| (|%Structure| (|bpPop2|) (|bpPop1|)))))
 
 (DEFUN |bpTypeList| ()
   (OR (|bpPileBracketed| #'|bpTypeItemList|)
-      (AND (|bpTerm| #'|bpIdList|) (|bpPush| (LIST (|bpPop1|))))))
+      (AND (|bpTypeItem|) (|bpPush| (LIST (|bpPop1|))))))
 
 (DEFUN |bpTypeItem| () (|bpTerm| #'|bpIdList|))
 
@@ -1147,7 +1137,7 @@
 
 (DEFUN |bpTerm| (|idListParser|)
   (OR
-   (AND (OR (|bpName|) (|bpTrap|))
+   (AND (|bpRequire| #'|bpName|)
         (OR
          (AND (|bpParenthesized| |idListParser|)
               (|bpPush| (|bfNameArgs| (|bpPop2|) (|bpPop1|))))
@@ -1157,7 +1147,7 @@
 (DEFUN |bpIdList| () (|bpTuple| #'|bpName|))
 
 (DEFUN |bpCase| ()
-  (AND (|bpEqKey| 'CASE) (OR (|bpWhere|) (|bpTrap|))
+  (AND (|bpEqKey| 'CASE) (|bpRequire| #'|bpWhere|)
        (OR (|bpEqKey| 'OF) (|bpMissing| 'OF)) (|bpPiledCaseItems|)))
 
 (DEFUN |bpPiledCaseItems| ()
@@ -1172,7 +1162,7 @@
 
 (DEFUN |bpCaseItem| ()
   (AND (OR (|bpTerm| #'|bpCasePatternVarList|) (|bpTrap|))
-       (OR (|bpEqKey| 'EXIT) (|bpTrap|)) (OR (|bpWhere|) (|bpTrap|))
+       (OR (|bpEqKey| 'EXIT) (|bpTrap|)) (|bpRequire| #'|bpWhere|)
        (|bpPush| (|bfCaseItem| (|bpPop2|) (|bpPop1|)))))
 
 (DEFUN |bpOutItem| ()
@@ -1182,7 +1172,7 @@
      (PROGN
       (SETQ |$op| NIL)
       (SETQ |$GenVarCounter| 0)
-      (OR (|bpComma|) (|bpTrap|))
+      (|bpRequire| #'|bpComma|)
       (SETQ |b| (|bpPop1|))
       (|bpPush|
        (COND ((AND (CONSP |b|) (EQ (CAR |b|) '+LINE)) (LIST |b|))