aboutsummaryrefslogtreecommitdiff
path: root/src/boot/strap/ast.clisp
diff options
context:
space:
mode:
Diffstat (limited to 'src/boot/strap/ast.clisp')
-rw-r--r--src/boot/strap/ast.clisp2086
1 files changed, 2086 insertions, 0 deletions
diff --git a/src/boot/strap/ast.clisp b/src/boot/strap/ast.clisp
new file mode 100644
index 00000000..591bd9bf
--- /dev/null
+++ b/src/boot/strap/ast.clisp
@@ -0,0 +1,2086 @@
+(EVAL-WHEN (:COMPILE-TOPLEVEL) (PROVIDE "boot-ast"))
+
+(IMPORT-MODULE "includer")
+
+(IN-PACKAGE "BOOTTRAN")
+
+(DEFPARAMETER |$bfClamming| NIL)
+
+(DEFTYPE |String| () 'STRING)
+
+(DEFTYPE |Symbol| () 'SYMBOL)
+
+(DEFTYPE |Sequence| () 'SEQUENCE)
+
+(DEFTYPE |List| () '(OR NIL CONS))
+
+(DEFUN |Name| #0=(|bfVar#1|) (CONS '|Name| (LIST . #0#)))
+
+(DEFUN |Command| #0=(|bfVar#2|) (CONS '|Command| (LIST . #0#)))
+
+(DEFUN |Module| #0=(|bfVar#3|) (CONS '|Module| (LIST . #0#)))
+
+(DEFUN |Import| #0=(|bfVar#4|) (CONS '|Import| (LIST . #0#)))
+
+(DEFUN |ImportSignature| #0=(|bfVar#5| |bfVar#6|)
+ (CONS '|ImportSignature| (LIST . #0#)))
+
+(DEFUN |TypeAlias| #0=(|bfVar#7| |bfVar#8| |bfVar#9|)
+ (CONS '|TypeAlias| (LIST . #0#)))
+
+(DEFUN |Signature| #0=(|bfVar#10| |bfVar#11|)
+ (CONS '|Signature| (LIST . #0#)))
+
+(DEFUN |Mapping| #0=(|bfVar#12| |bfVar#13|)
+ (CONS '|Mapping| (LIST . #0#)))
+
+(DEFUN |SuffixDot| #0=(|bfVar#14|) (CONS '|SuffixDot| (LIST . #0#)))
+
+(DEFUN |Quote| #0=(|bfVar#15|) (CONS '|Quote| (LIST . #0#)))
+
+(DEFUN |EqualName| #0=(|bfVar#16|) (CONS '|EqualName| (LIST . #0#)))
+
+(DEFUN |Colon| #0=(|bfVar#17|) (CONS '|Colon| (LIST . #0#)))
+
+(DEFUN |QualifiedName| #0=(|bfVar#18| |bfVar#19|)
+ (CONS '|QualifiedName| (LIST . #0#)))
+
+(DEFUN |Bracket| #0=(|bfVar#20|) (CONS '|Bracket| (LIST . #0#)))
+
+(DEFUN |UnboundedSegment| #0=(|bfVar#21|)
+ (CONS '|UnboundedSegment| (LIST . #0#)))
+
+(DEFUN |BoundedSgement| #0=(|bfVar#22| |bfVar#23|)
+ (CONS '|BoundedSgement| (LIST . #0#)))
+
+(DEFUN |Tuple| #0=(|bfVar#24|) (CONS '|Tuple| (LIST . #0#)))
+
+(DEFUN |ColonAppend| #0=(|bfVar#25| |bfVar#26|)
+ (CONS '|ColonAppend| (LIST . #0#)))
+
+(DEFUN |Is| #0=(|bfVar#27| |bfVar#28|) (CONS '|Is| (LIST . #0#)))
+
+(DEFUN |Isnt| #0=(|bfVar#29| |bfVar#30|) (CONS '|Isnt| (LIST . #0#)))
+
+(DEFUN |Reduce| #0=(|bfVar#31| |bfVar#32|)
+ (CONS '|Reduce| (LIST . #0#)))
+
+(DEFUN |PrefixExpr| #0=(|bfVar#33| |bfVar#34|)
+ (CONS '|PrefixExpr| (LIST . #0#)))
+
+(DEFUN |Call| #0=(|bfVar#35| |bfVar#36|) (CONS '|Call| (LIST . #0#)))
+
+(DEFUN |InfixExpr| #0=(|bfVar#37| |bfVar#38| |bfVar#39|)
+ (CONS '|InfixExpr| (LIST . #0#)))
+
+(DEFUN |ConstantDefinition| #0=(|bfVar#40| |bfVar#41|)
+ (CONS '|ConstantDefinition| (LIST . #0#)))
+
+(DEFUN |Definition| #0=(|bfVar#42| |bfVar#43| |bfVar#44| |bfVar#45|)
+ (CONS '|Definition| (LIST . #0#)))
+
+(DEFUN |Macro| #0=(|bfVar#46| |bfVar#47| |bfVar#48|)
+ (CONS '|Macro| (LIST . #0#)))
+
+(DEFUN |SuchThat| #0=(|bfVar#49|) (CONS '|SuchThat| (LIST . #0#)))
+
+(DEFUN |Assignment| #0=(|bfVar#50| |bfVar#51|)
+ (CONS '|Assignment| (LIST . #0#)))
+
+(DEFUN |While| #0=(|bfVar#52|) (CONS '|While| (LIST . #0#)))
+
+(DEFUN |Until| #0=(|bfVar#53|) (CONS '|Until| (LIST . #0#)))
+
+(DEFUN |For| #0=(|bfVar#54| |bfVar#55| |bfVar#56|)
+ (CONS '|For| (LIST . #0#)))
+
+(DEFUN |Exit| #0=(|bfVar#57| |bfVar#58|) (CONS '|Exit| (LIST . #0#)))
+
+(DEFUN |Iterators| #0=(|bfVar#59|) (CONS '|Iterators| (LIST . #0#)))
+
+(DEFUN |Cross| #0=(|bfVar#60|) (CONS '|Cross| (LIST . #0#)))
+
+(DEFUN |Repeat| #0=(|bfVar#61| |bfVar#62|)
+ (CONS '|Repeat| (LIST . #0#)))
+
+(DEFUN |Pile| #0=(|bfVar#63|) (CONS '|Pile| (LIST . #0#)))
+
+(DEFUN |Append| #0=(|bfVar#64|) (CONS '|Append| (LIST . #0#)))
+
+(DEFUN |Case| #0=(|bfVar#65| |bfVar#66|) (CONS '|Case| (LIST . #0#)))
+
+(DEFUN |Return| #0=(|bfVar#67|) (CONS '|Return| (LIST . #0#)))
+
+(DEFUN |Where| #0=(|bfVar#68| |bfVar#69|)
+ (CONS '|Where| (LIST . #0#)))
+
+(DEFUN |Structure| #0=(|bfVar#70| |bfVar#71|)
+ (CONS '|Structure| (LIST . #0#)))
+
+(DEFPARAMETER |$inDefIS| NIL)
+
+(DEFUN |bfGenSymbol| ()
+ (PROG ()
+ (DECLARE (SPECIAL |$GenVarCounter|))
+ (RETURN
+ (PROGN
+ (SETQ |$GenVarCounter| (+ |$GenVarCounter| 1))
+ (INTERN (CONCAT "bfVar#" (STRINGIMAGE |$GenVarCounter|)))))))
+
+(DEFUN |bfListOf| (|x|) (PROG () (RETURN |x|)))
+
+(DEFUN |bfColon| (|x|) (PROG () (RETURN (LIST 'COLON |x|))))
+
+(DEFUN |bfColonColon| (|package| |name|)
+ (PROG () (RETURN (INTERN (SYMBOL-NAME |name|) |package|))))
+
+(DEFUN |bfSymbol| (|x|)
+ (PROG () (RETURN (COND ((STRINGP |x|) |x|) ('T (LIST 'QUOTE |x|))))))
+
+(DEFUN |bfDot| () (PROG () (RETURN 'DOT)))
+
+(DEFUN |bfSuffixDot| (|x|) (PROG () (RETURN (LIST |x| 'DOT))))
+
+(DEFUN |bfEqual| (|name|) (PROG () (RETURN (LIST 'EQUAL |name|))))
+
+(DEFUN |bfBracket| (|part|) (PROG () (RETURN |part|)))
+
+(DEFUN |bfPile| (|part|) (PROG () (RETURN |part|)))
+
+(DEFUN |bfAppend| (|x|) (PROG () (RETURN (APPLY #'APPEND |x|))))
+
+(DEFUN |bfColonAppend| (|x| |y|)
+ (PROG (|a|)
+ (RETURN
+ (COND
+ ((NULL |x|)
+ (COND
+ ((AND (CONSP |y|) (EQ (CAR |y|) 'BVQUOTE)
+ (PROGN (SETQ |a| (CDR |y|)) 'T))
+ (LIST '&REST (CONS 'QUOTE |a|)))
+ (#0='T (LIST '&REST |y|))))
+ (#0# (CONS (CAR |x|) (|bfColonAppend| (CDR |x|) |y|)))))))
+
+(DEFUN |bfDefinition| (|bflhsitems| |bfrhs| |body|)
+ (PROG () (RETURN (LIST 'DEF |bflhsitems| |bfrhs| |body|))))
+
+(DEFUN |bfMDefinition| (|bflhsitems| |bfrhs| |body|)
+ (PROG () (RETURN (|bfMDef| 'MDEF |bflhsitems| |bfrhs| |body|))))
+
+(DEFUN |bfCompDef| (|x|)
+ (PROG (|body| |ISTMP#3| |args| |ISTMP#2| |op| |ISTMP#1| |def|
+ |bfVar#73| |bfVar#72|)
+ (RETURN
+ (PROGN
+ (SETQ |bfVar#72| |x|)
+ (SETQ |bfVar#73| (CDR |bfVar#72|))
+ (CASE (CAR |bfVar#72|)
+ (|ConstantDefinition|
+ (LET ((|n| (CAR |bfVar#73|)) (|e| (CADR |bfVar#73|)))
+ |x|))
+ (T (COND
+ ((AND (CONSP |x|)
+ (PROGN
+ (SETQ |def| (CAR |x|))
+ (SETQ |ISTMP#1| (CDR |x|))
+ (AND (CONSP |ISTMP#1|)
+ (PROGN
+ (SETQ |op| (CAR |ISTMP#1|))
+ (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+ (AND (CONSP |ISTMP#2|)
+ (PROGN
+ (SETQ |args| (CAR |ISTMP#2|))
+ (SETQ |ISTMP#3| (CDR |ISTMP#2|))
+ (AND (CONSP |ISTMP#3|)
+ (EQ (CDR |ISTMP#3|) NIL)
+ (PROGN
+ (SETQ |body| (CAR |ISTMP#3|))
+ 'T))))))))
+ (|bfDef| |def| |op| |args| |body|))
+ ('T (|coreError| "invalid AST")))))))))
+
+(DEFUN |bfBeginsDollar| (|x|)
+ (PROG () (RETURN (EQL (ELT "$" 0) (ELT (PNAME |x|) 0)))))
+
+(DEFUN |compFluid| (|id|) (PROG () (RETURN (LIST 'FLUID |id|))))
+
+(DEFUN |compFluidize| (|x|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((AND (IDENTP |x|) (|bfBeginsDollar| |x|)) (|compFluid| |x|))
+ ((ATOM |x|) |x|)
+ ((EQCAR |x| 'QUOTE) |x|)
+ ('T
+ (CONS (|compFluidize| (CAR |x|)) (|compFluidize| (CDR |x|))))))))
+
+(DEFUN |bfTuple| (|x|) (PROG () (RETURN (CONS 'TUPLE |x|))))
+
+(DEFUN |bfTupleP| (|x|) (PROG () (RETURN (EQCAR |x| 'TUPLE))))
+
+(DEFUN |bfTupleIf| (|x|)
+ (PROG ()
+ (RETURN (COND ((|bfTupleP| |x|) |x|) ('T (|bfTuple| |x|))))))
+
+(DEFUN |bfTupleConstruct| (|b|)
+ (PROG (|ISTMP#1| |a|)
+ (RETURN
+ (PROGN
+ (SETQ |a| (COND ((|bfTupleP| |b|) (CDR |b|)) ('T (LIST |b|))))
+ (COND
+ ((LET ((|bfVar#75| NIL) (|bfVar#74| |a|) (|x| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#74|)
+ (PROGN (SETQ |x| (CAR |bfVar#74|)) NIL))
+ (RETURN |bfVar#75|))
+ ('T
+ (PROGN
+ (SETQ |bfVar#75|
+ (AND (CONSP |x|) (EQ (CAR |x|) 'COLON)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |x|))
+ (AND (CONSP |ISTMP#1|)
+ (EQ (CDR |ISTMP#1|) NIL)))))
+ (COND (|bfVar#75| (RETURN |bfVar#75|))))))
+ (SETQ |bfVar#74| (CDR |bfVar#74|))))
+ (|bfMakeCons| |a|))
+ ('T (CONS 'LIST |a|)))))))
+
+(DEFUN |bfConstruct| (|b|)
+ (PROG (|a|)
+ (RETURN
+ (PROGN
+ (SETQ |a| (COND ((|bfTupleP| |b|) (CDR |b|)) ('T (LIST |b|))))
+ (|bfMakeCons| |a|)))))
+
+(DEFUN |bfMakeCons| (|l|)
+ (PROG (|l1| |a| |ISTMP#2| |ISTMP#1|)
+ (RETURN
+ (COND
+ ((NULL |l|) NIL)
+ ((AND (CONSP |l|)
+ (PROGN
+ (SETQ |ISTMP#1| (CAR |l|))
+ (AND (CONSP |ISTMP#1|) (EQ (CAR |ISTMP#1|) 'COLON)
+ (PROGN
+ (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+ (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+ (PROGN (SETQ |a| (CAR |ISTMP#2|)) #0='T)))))
+ (PROGN (SETQ |l1| (CDR |l|)) #0#))
+ (COND
+ (|l1| (LIST 'APPEND |a| (|bfMakeCons| |l1|)))
+ (#1='T |a|)))
+ (#1# (LIST 'CONS (CAR |l|) (|bfMakeCons| (CDR |l|))))))))
+
+(DEFUN |bfFor| (|bflhs| U |step|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((EQCAR U '|tails|) (|bfForTree| 'ON |bflhs| (CADR U)))
+ ((EQCAR U 'SEGMENT)
+ (|bfSTEP| |bflhs| (CADR U) |step| (CADDR U)))
+ ('T (|bfForTree| 'IN |bflhs| U))))))
+
+(DEFUN |bfForTree| (OP |lhs| |whole|)
+ (PROG (G)
+ (RETURN
+ (PROGN
+ (SETQ |whole|
+ (COND
+ ((|bfTupleP| |whole|) (|bfMakeCons| (CDR |whole|)))
+ (#0='T |whole|)))
+ (COND
+ ((ATOM |lhs|) (|bfINON| (LIST OP |lhs| |whole|)))
+ (#1='T
+ (PROGN
+ (SETQ |lhs|
+ (COND
+ ((|bfTupleP| |lhs|) (CADR |lhs|))
+ (#0# |lhs|)))
+ (COND
+ ((EQCAR |lhs| 'L%T)
+ (PROGN
+ (SETQ G (CADR |lhs|))
+ (APPEND (|bfINON| (LIST OP G |whole|))
+ (|bfSuchthat| (|bfIS| G (CADDR |lhs|))))))
+ (#1#
+ (PROGN
+ (SETQ G (|bfGenSymbol|))
+ (APPEND (|bfINON| (LIST OP G |whole|))
+ (|bfSuchthat| (|bfIS| G |lhs|)))))))))))))
+
+(DEFUN |bfSTEP| (|id| |fst| |step| |lst|)
+ (PROG (|suc| |ex| |pred| |final| |g2| |inc| |g1| |initval| |initvar|)
+ (RETURN
+ (PROGN
+ (SETQ |initvar| (LIST |id|))
+ (SETQ |initval| (LIST |fst|))
+ (SETQ |inc|
+ (COND
+ ((ATOM |step|) |step|)
+ (#0='T (SETQ |g1| (|bfGenSymbol|))
+ (SETQ |initvar| (CONS |g1| |initvar|))
+ (SETQ |initval| (CONS |step| |initval|)) |g1|)))
+ (SETQ |final|
+ (COND
+ ((ATOM |lst|) |lst|)
+ (#0# (SETQ |g2| (|bfGenSymbol|))
+ (SETQ |initvar| (CONS |g2| |initvar|))
+ (SETQ |initval| (CONS |lst| |initval|)) |g2|)))
+ (SETQ |ex|
+ (COND
+ ((NULL |lst|) NIL)
+ ((INTEGERP |inc|)
+ (PROGN
+ (SETQ |pred| (COND ((MINUSP |inc|) '<) (#0# '>)))
+ (LIST (LIST |pred| |id| |final|))))
+ ('T
+ (LIST (LIST 'COND
+ (LIST (LIST 'MINUSP |inc|)
+ (LIST '< |id| |final|))
+ (LIST 'T (LIST '> |id| |final|)))))))
+ (SETQ |suc| (LIST (LIST 'SETQ |id| (LIST '+ |id| |inc|))))
+ (LIST (LIST |initvar| |initval| |suc| NIL |ex| NIL))))))
+
+(DEFUN |bfINON| (|x|)
+ (PROG (|whole| |id| |op|)
+ (RETURN
+ (PROGN
+ (SETQ |op| (CAR |x|))
+ (SETQ |id| (CADR . #0=(|x|)))
+ (SETQ |whole| (CADDR . #0#))
+ (COND
+ ((EQ |op| 'ON) (|bfON| |id| |whole|))
+ ('T (|bfIN| |id| |whole|)))))))
+
+(DEFUN |bfIN| (|x| E)
+ (PROG (|g|)
+ (RETURN
+ (PROGN
+ (SETQ |g| (|bfGenSymbol|))
+ (LIST (LIST (LIST |g| |x|) (LIST E NIL)
+ (LIST (LIST 'SETQ |g| (LIST 'CDR |g|))) NIL
+ (LIST (LIST 'OR (LIST 'ATOM |g|)
+ (LIST 'PROGN
+ (LIST 'SETQ |x| (LIST 'CAR |g|))
+ 'NIL)))
+ NIL))))))
+
+(DEFUN |bfON| (|x| E)
+ (PROG ()
+ (RETURN
+ (LIST (LIST (LIST |x|) (LIST E)
+ (LIST (LIST 'SETQ |x| (LIST 'CDR |x|))) NIL
+ (LIST (LIST 'ATOM |x|)) NIL)))))
+
+(DEFUN |bfSuchthat| (|p|)
+ (PROG () (RETURN (LIST (LIST NIL NIL NIL (LIST |p|) NIL NIL)))))
+
+(DEFUN |bfWhile| (|p|)
+ (PROG ()
+ (RETURN (LIST (LIST NIL NIL NIL NIL (LIST (|bfNOT| |p|)) NIL)))))
+
+(DEFUN |bfUntil| (|p|)
+ (PROG (|g|)
+ (RETURN
+ (PROGN
+ (SETQ |g| (|bfGenSymbol|))
+ (LIST (LIST (LIST |g|) (LIST NIL) (LIST (LIST 'SETQ |g| |p|))
+ NIL (LIST |g|) NIL))))))
+
+(DEFUN |bfIterators| (|x|) (PROG () (RETURN (CONS 'ITERATORS |x|))))
+
+(DEFUN |bfCross| (|x|) (PROG () (RETURN (CONS 'CROSS |x|))))
+
+(DEFUN |bfLp| (|iters| |body|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((EQCAR |iters| 'ITERATORS) (|bfLp1| (CDR |iters|) |body|))
+ ('T (|bfLpCross| (CDR |iters|) |body|))))))
+
+(DEFUN |bfLpCross| (|iters| |body|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((NULL (CDR |iters|)) (|bfLp| (CAR |iters|) |body|))
+ ('T (|bfLp| (CAR |iters|) (|bfLpCross| (CDR |iters|) |body|)))))))
+
+(DEFUN |bfSep| (|iters|)
+ (PROG (|r| |f|)
+ (RETURN
+ (COND
+ ((NULL |iters|) (LIST NIL NIL NIL NIL NIL NIL))
+ ('T (SETQ |f| (CAR |iters|)) (SETQ |r| (|bfSep| (CDR |iters|)))
+ (LET ((|bfVar#78| NIL) (|bfVar#76| |f|) (|i| NIL)
+ (|bfVar#77| |r|) (|j| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#76|)
+ (PROGN (SETQ |i| (CAR |bfVar#76|)) NIL)
+ (ATOM |bfVar#77|)
+ (PROGN (SETQ |j| (CAR |bfVar#77|)) NIL))
+ (RETURN (NREVERSE |bfVar#78|)))
+ ('T
+ (SETQ |bfVar#78| (CONS (APPEND |i| |j|) |bfVar#78|))))
+ (SETQ |bfVar#76| (CDR |bfVar#76|))
+ (SETQ |bfVar#77| (CDR |bfVar#77|)))))))))
+
+(DEFUN |bfReduce| (|op| |y|)
+ (PROG (|it| |ny| |g2| |body| |g1| |g| |init| |a|)
+ (RETURN
+ (PROGN
+ (SETQ |a|
+ (COND ((EQCAR |op| 'QUOTE) (CADR |op|)) (#0='T |op|)))
+ (SETQ |op| (|bfReName| |a|))
+ (SETQ |init| (GET |op| 'SHOETHETA))
+ (SETQ |g| (|bfGenSymbol|))
+ (SETQ |g1| (|bfGenSymbol|))
+ (SETQ |body| (LIST 'SETQ |g| (LIST |op| |g| |g1|)))
+ (COND
+ ((NULL |init|) (SETQ |g2| (|bfGenSymbol|))
+ (SETQ |init| (LIST 'CAR |g2|)) (SETQ |ny| (LIST 'CDR |g2|))
+ (SETQ |it|
+ (CONS 'ITERATORS
+ (LIST (LIST (LIST (LIST |g|) (LIST |init|) NIL
+ NIL NIL (LIST |g|)))
+ (|bfIN| |g1| |ny|))))
+ (|bfMKPROGN|
+ (LIST (LIST 'L%T |g2| |y|) (|bfLp| |it| |body|))))
+ (#0# (SETQ |init| (CAR |init|))
+ (SETQ |it|
+ (CONS 'ITERATORS
+ (LIST (LIST (LIST (LIST |g|) (LIST |init|) NIL
+ NIL NIL (LIST |g|)))
+ (|bfIN| |g1| |y|))))
+ (|bfLp| |it| |body|)))))))
+
+(DEFUN |bfReduceCollect| (|op| |y|)
+ (PROG (|init| |a| |itl| |body|)
+ (RETURN
+ (COND
+ ((EQCAR |y| 'COLLECT) (SETQ |body| (ELT |y| 1))
+ (SETQ |itl| (ELT |y| 2))
+ (SETQ |a|
+ (COND ((EQCAR |op| 'QUOTE) (CADR |op|)) (#0='T |op|)))
+ (SETQ |op| (|bfReName| |a|))
+ (SETQ |init| (GET |op| 'SHOETHETA))
+ (|bfOpReduce| |op| |init| |body| |itl|))
+ (#0# (SETQ |a| (|bfTupleConstruct| (ELT |y| 1)))
+ (|bfReduce| |op| |a|))))))
+
+(DEFUN |bfDCollect| (|y| |itl|)
+ (PROG () (RETURN (LIST 'COLLECT |y| |itl|))))
+
+(DEFUN |bfDTuple| (|x|) (PROG () (RETURN (LIST 'DTUPLE |x|))))
+
+(DEFUN |bfCollect| (|y| |itl|)
+ (PROG (|newBody| |a| |ISTMP#1|)
+ (RETURN
+ (COND
+ ((AND (CONSP |y|) (EQ (CAR |y|) 'COLON)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |y|))
+ (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+ (PROGN (SETQ |a| (CAR |ISTMP#1|)) 'T))))
+ (|bf0APPEND| |a| |itl|))
+ ((AND (CONSP |y|) (EQ (CAR |y|) 'TUPLE))
+ (PROGN
+ (SETQ |newBody| (|bfConstruct| |y|))
+ (|bf0APPEND| |newBody| |itl|)))
+ ('T (|bf0COLLECT| |y| |itl|))))))
+
+(DEFUN |bf0COLLECT| (|y| |itl|)
+ (PROG () (RETURN (|bfListReduce| 'CONS |y| |itl|))))
+
+(DEFUN |bf0APPEND| (|y| |itl|)
+ (PROG (|extrait| |body| |g|)
+ (RETURN
+ (PROGN
+ (SETQ |g| (|bfGenSymbol|))
+ (SETQ |body|
+ (LIST 'SETQ |g| (LIST 'APPEND (LIST 'REVERSE |y|) |g|)))
+ (SETQ |extrait|
+ (LIST (LIST (LIST |g|) (LIST NIL) NIL NIL NIL
+ (LIST (LIST 'NREVERSE |g|)))))
+ (|bfLp2| |extrait| |itl| |body|)))))
+
+(DEFUN |bfListReduce| (|op| |y| |itl|)
+ (PROG (|extrait| |body| |g|)
+ (RETURN
+ (PROGN
+ (SETQ |g| (|bfGenSymbol|))
+ (SETQ |body| (LIST 'SETQ |g| (LIST |op| |y| |g|)))
+ (SETQ |extrait|
+ (LIST (LIST (LIST |g|) (LIST NIL) NIL NIL NIL
+ (LIST (LIST 'NREVERSE |g|)))))
+ (|bfLp2| |extrait| |itl| |body|)))))
+
+(DEFUN |bfLp1| (|iters| |body|)
+ (PROG (|loop| |nbody| |value| |exits| |filters| |sucs| |inits| |vars|
+ |LETTMP#1|)
+ (RETURN
+ (PROGN
+ (SETQ |LETTMP#1| (|bfSep| (|bfAppend| |iters|)))
+ (SETQ |vars| (CAR |LETTMP#1|))
+ (SETQ |inits| (CADR . #0=(|LETTMP#1|)))
+ (SETQ |sucs| (CADDR . #0#))
+ (SETQ |filters| (CADDDR . #0#))
+ (SETQ |exits| (CAR #1=(CDDDDR . #0#)))
+ (SETQ |value| (CADR #1#))
+ (SETQ |nbody|
+ (COND
+ ((NULL |filters|) |body|)
+ (#2='T (|bfAND| (APPEND |filters| (CONS |body| NIL))))))
+ (SETQ |value| (COND ((NULL |value|) 'NIL) (#2# (CAR |value|))))
+ (SETQ |exits|
+ (LIST 'COND
+ (LIST (|bfOR| |exits|) (LIST 'RETURN |value|))
+ (LIST ''T |nbody|)))
+ (SETQ |loop| (CONS 'LOOP (CONS |exits| |sucs|)))
+ (COND
+ (|vars| (SETQ |loop|
+ (LIST 'LET
+ (LET ((|bfVar#81| NIL)
+ (|bfVar#79| |vars|) (|v| NIL)
+ (|bfVar#80| |inits|) (|i| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#79|)
+ (PROGN
+ (SETQ |v| (CAR |bfVar#79|))
+ NIL)
+ (ATOM |bfVar#80|)
+ (PROGN
+ (SETQ |i| (CAR |bfVar#80|))
+ NIL))
+ (RETURN (NREVERSE |bfVar#81|)))
+ ('T
+ (SETQ |bfVar#81|
+ (CONS (LIST |v| |i|) |bfVar#81|))))
+ (SETQ |bfVar#79| (CDR |bfVar#79|))
+ (SETQ |bfVar#80| (CDR |bfVar#80|))))
+ |loop|))))
+ |loop|))))
+
+(DEFUN |bfLp2| (|extrait| |itl| |body|)
+ (PROG (|iters|)
+ (RETURN
+ (COND
+ ((EQCAR |itl| 'ITERATORS)
+ (|bfLp1| (CONS |extrait| (CDR |itl|)) |body|))
+ ('T
+ (PROGN
+ (SETQ |iters| (CDR |itl|))
+ (|bfLpCross|
+ (CONS (CONS 'ITERATORS (CONS |extrait| (CDAR |iters|)))
+ (CDR |iters|))
+ |body|)))))))
+
+(DEFUN |bfOpReduce| (|op| |init| |y| |itl|)
+ (PROG (|extrait| |g1| |body| |g|)
+ (RETURN
+ (PROGN
+ (SETQ |g| (|bfGenSymbol|))
+ (SETQ |body|
+ (COND
+ ((EQ |op| 'AND)
+ (|bfMKPROGN|
+ (LIST (LIST 'SETQ |g| |y|)
+ (LIST 'COND
+ (LIST (LIST 'NOT |g|)
+ (LIST 'RETURN 'NIL))))))
+ ((EQ |op| 'OR)
+ (|bfMKPROGN|
+ (LIST (LIST 'SETQ |g| |y|)
+ (LIST 'COND (LIST |g| (LIST 'RETURN |g|))))))
+ ('T (LIST 'SETQ |g| (LIST |op| |g| |y|)))))
+ (COND
+ ((NULL |init|) (SETQ |g1| (|bfGenSymbol|))
+ (SETQ |init| (LIST 'CAR |g1|)) (SETQ |y| (LIST 'CDR |g1|))
+ (SETQ |extrait|
+ (LIST (LIST (LIST |g|) (LIST |init|) NIL NIL NIL
+ (LIST |g|))))
+ (|bfMKPROGN|
+ (LIST (LIST 'L%T |g1| |y|)
+ (|bfLp2| |extrait| |itl| |body|))))
+ ('T (SETQ |init| (CAR |init|))
+ (SETQ |extrait|
+ (LIST (LIST (LIST |g|) (LIST |init|) NIL NIL NIL
+ (LIST |g|))))
+ (|bfLp2| |extrait| |itl| |body|)))))))
+
+(DEFUN |bfLoop1| (|body|)
+ (PROG () (RETURN (|bfLp| (|bfIterators| NIL) |body|))))
+
+(DEFUN |bfSegment1| (|lo|)
+ (PROG () (RETURN (LIST 'SEGMENT |lo| NIL))))
+
+(DEFUN |bfSegment2| (|lo| |hi|)
+ (PROG () (RETURN (LIST 'SEGMENT |lo| |hi|))))
+
+(DEFUN |bfForInBy| (|variable| |collection| |step|)
+ (PROG () (RETURN (|bfFor| |variable| |collection| |step|))))
+
+(DEFUN |bfForin| (|lhs| U) (PROG () (RETURN (|bfFor| |lhs| U 1))))
+
+(DEFUN |bfLocal| (|a| |b|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((EQ |b| 'FLUID) (|compFluid| |a|))
+ ((EQ |b| '|fluid|) (|compFluid| |a|))
+ ((EQ |b| '|local|) (|compFluid| |a|))
+ ('T |a|)))))
+
+(DEFUN |bfTake| (|n| |x|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((NULL |x|) |x|)
+ ((EQL |n| 0) NIL)
+ ('T (CONS (CAR |x|) (|bfTake| (- |n| 1) (CDR |x|))))))))
+
+(DEFUN |bfDrop| (|n| |x|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((OR (NULL |x|) (EQL |n| 0)) |x|)
+ ('T (|bfDrop| (- |n| 1) (CDR |x|)))))))
+
+(DEFUN |bfDefSequence| (|l|) (PROG () (RETURN (CONS 'SEQ |l|))))
+
+(DEFUN |bfReturnNoName| (|a|) (PROG () (RETURN (LIST 'RETURN |a|))))
+
+(DEFUN |bfSUBLIS| (|p| |e|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((ATOM |e|) (|bfSUBLIS1| |p| |e|))
+ ((EQCAR |e| 'QUOTE) |e|)
+ ('T
+ (CONS (|bfSUBLIS| |p| (CAR |e|)) (|bfSUBLIS| |p| (CDR |e|))))))))
+
+(DEFUN |bfSUBLIS1| (|p| |e|)
+ (PROG (|f|)
+ (RETURN
+ (COND
+ ((NULL |p|) |e|)
+ (#0='T
+ (PROGN
+ (SETQ |f| (CAR |p|))
+ (COND
+ ((EQ (CAR |f|) |e|) (|bfSUBLIS| |p| (CDR |f|)))
+ (#0# (|bfSUBLIS1| (CDR |p|) |e|)))))))))
+
+(DEFUN |defSheepAndGoats| (|x|)
+ (PROG (|defstack| |op1| |opassoc| |argl| |body| |args| |op| |def|)
+ (DECLARE (SPECIAL |$op|))
+ (RETURN
+ (COND
+ ((EQCAR |x| 'DEF)
+ (PROGN
+ (SETQ |def| (CAR |x|))
+ (SETQ |op| (CADR . #0=(|x|)))
+ (SETQ |args| (CADDR . #0#))
+ (SETQ |body| (CADDDR . #0#))
+ (SETQ |argl|
+ (COND
+ ((|bfTupleP| |args|) (CDR |args|))
+ (#1='T (LIST |args|))))
+ (COND
+ ((NULL |argl|) (SETQ |opassoc| (LIST (CONS |op| |body|)))
+ (LIST |opassoc| NIL NIL))
+ (#1#
+ (SETQ |op1|
+ (INTERN (CONCAT (PNAME |$op|) "," (PNAME |op|))))
+ (SETQ |opassoc| (LIST (CONS |op| |op1|)))
+ (SETQ |defstack| (LIST (LIST 'DEF |op1| |args| |body|)))
+ (LIST |opassoc| |defstack| NIL)))))
+ ((EQCAR |x| 'SEQ) (|defSheepAndGoatsList| (CDR |x|)))
+ ('T (LIST NIL NIL (LIST |x|)))))))
+
+(DEFUN |defSheepAndGoatsList| (|x|)
+ (PROG (|nondefs1| |defs1| |opassoc1| |nondefs| |defs| |opassoc|
+ |LETTMP#1|)
+ (RETURN
+ (COND
+ ((NULL |x|) (LIST NIL NIL NIL))
+ ('T (SETQ |LETTMP#1| (|defSheepAndGoats| (CAR |x|)))
+ (SETQ |opassoc| (CAR |LETTMP#1|))
+ (SETQ |defs| (CADR . #0=(|LETTMP#1|)))
+ (SETQ |nondefs| (CADDR . #0#))
+ (SETQ |LETTMP#1| (|defSheepAndGoatsList| (CDR |x|)))
+ (SETQ |opassoc1| (CAR |LETTMP#1|))
+ (SETQ |defs1| (CADR . #1=(|LETTMP#1|)))
+ (SETQ |nondefs1| (CADDR . #1#))
+ (LIST (APPEND |opassoc| |opassoc1|) (APPEND |defs| |defs1|)
+ (APPEND |nondefs| |nondefs1|)))))))
+
+(DEFUN |bfLetForm| (|lhs| |rhs|)
+ (PROG () (RETURN (LIST 'L%T |lhs| |rhs|))))
+
+(DEFUN |bfLET1| (|lhs| |rhs|)
+ (PROG (|let1| |g| |l2| |l1| |name| |rhs1| |ISTMP#1|)
+ (DECLARE (SPECIAL |$letGenVarCounter|))
+ (RETURN
+ (COND
+ ((IDENTP |lhs|) (|bfLetForm| |lhs| |rhs|))
+ ((AND (CONSP |lhs|) (EQ (CAR |lhs|) 'FLUID)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |lhs|))
+ (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL))))
+ (|bfLetForm| |lhs| |rhs|))
+ ((AND (IDENTP |rhs|) (NULL (|bfCONTAINED| |rhs| |lhs|)))
+ (PROGN
+ (SETQ |rhs1| (|bfLET2| |lhs| |rhs|))
+ (COND
+ ((EQCAR |rhs1| 'L%T) (|bfMKPROGN| (LIST |rhs1| |rhs|)))
+ ((EQCAR |rhs1| 'PROGN) (APPEND |rhs1| (LIST |rhs|)))
+ (#0='T
+ (PROGN
+ (COND
+ ((IDENTP (CAR |rhs1|))
+ (SETQ |rhs1| (CONS |rhs1| NIL))))
+ (|bfMKPROGN| (APPEND |rhs1| (CONS |rhs| NIL))))))))
+ ((AND (CONSP |rhs|) (EQCAR |rhs| 'L%T)
+ (IDENTP (SETQ |name| (CADR |rhs|))))
+ (PROGN
+ (SETQ |l1| (|bfLET1| |name| (CADDR |rhs|)))
+ (SETQ |l2| (|bfLET1| |lhs| |name|))
+ (COND
+ ((EQCAR |l2| 'PROGN) (|bfMKPROGN| (CONS |l1| (CDR |l2|))))
+ (#0#
+ (PROGN
+ (COND
+ ((IDENTP (CAR |l2|)) (SETQ |l2| (CONS |l2| NIL))))
+ (|bfMKPROGN|
+ (CONS |l1| (APPEND |l2| (CONS |name| NIL)))))))))
+ (#0#
+ (PROGN
+ (SETQ |g|
+ (INTERN (CONCAT "LETTMP#"
+ (STRINGIMAGE |$letGenVarCounter|))))
+ (SETQ |$letGenVarCounter| (+ |$letGenVarCounter| 1))
+ (SETQ |rhs1| (LIST 'L%T |g| |rhs|))
+ (SETQ |let1| (|bfLET1| |lhs| |g|))
+ (COND
+ ((EQCAR |let1| 'PROGN)
+ (|bfMKPROGN| (CONS |rhs1| (CDR |let1|))))
+ (#0#
+ (PROGN
+ (COND
+ ((IDENTP (CAR |let1|))
+ (SETQ |let1| (CONS |let1| NIL))))
+ (|bfMKPROGN|
+ (CONS |rhs1| (APPEND |let1| (CONS |g| NIL)))))))))))))
+
+(DEFUN |bfCONTAINED| (|x| |y|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((EQ |x| |y|) T)
+ ((ATOM |y|) NIL)
+ ('T
+ (OR (|bfCONTAINED| |x| (CAR |y|))
+ (|bfCONTAINED| |x| (CDR |y|))))))))
+
+(DEFUN |bfLET2| (|lhs| |rhs|)
+ (PROG (|isPred| |val1| |ISTMP#3| |g| |rev| |patrev| |l2| |l1| |var2|
+ |var1| |b| |ISTMP#2| |a| |ISTMP#1|)
+ (DECLARE (SPECIAL |$inDefIS| |$letGenVarCounter|))
+ (RETURN
+ (COND
+ ((IDENTP |lhs|) (|bfLetForm| |lhs| |rhs|))
+ ((NULL |lhs|) NIL)
+ ((AND (CONSP |lhs|) (EQ (CAR |lhs|) 'FLUID)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |lhs|))
+ (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL))))
+ (|bfLetForm| |lhs| |rhs|))
+ ((AND (CONSP |lhs|) (EQ (CAR |lhs|) 'L%T)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |lhs|))
+ (AND (CONSP |ISTMP#1|)
+ (PROGN
+ (SETQ |a| (CAR |ISTMP#1|))
+ (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+ (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+ (PROGN (SETQ |b| (CAR |ISTMP#2|)) #0='T))))))
+ (PROGN
+ (SETQ |a| (|bfLET2| |a| |rhs|))
+ (COND
+ ((NULL (SETQ |b| (|bfLET2| |b| |rhs|))) |a|)
+ ((ATOM |b|) (LIST |a| |b|))
+ ((CONSP (CAR |b|)) (CONS |a| |b|))
+ (#1='T (LIST |a| |b|)))))
+ ((AND (CONSP |lhs|) (EQ (CAR |lhs|) 'CONS)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |lhs|))
+ (AND (CONSP |ISTMP#1|)
+ (PROGN
+ (SETQ |var1| (CAR |ISTMP#1|))
+ (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+ (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+ (PROGN (SETQ |var2| (CAR |ISTMP#2|)) #0#))))))
+ (COND
+ ((OR (EQ |var1| 'DOT)
+ (AND (CONSP |var1|) (EQCAR |var1| 'QUOTE)))
+ (|bfLET2| |var2| (|addCARorCDR| 'CDR |rhs|)))
+ (#1#
+ (PROGN
+ (SETQ |l1| (|bfLET2| |var1| (|addCARorCDR| 'CAR |rhs|)))
+ (COND
+ ((OR (NULL |var2|) (EQ |var2| 'DOT)) |l1|)
+ (#1#
+ (PROGN
+ (COND
+ ((AND (CONSP |l1|) (ATOM (CAR |l1|)))
+ (SETQ |l1| (CONS |l1| NIL))))
+ (COND
+ ((IDENTP |var2|)
+ (APPEND |l1|
+ (CONS (|bfLetForm| |var2|
+ (|addCARorCDR| 'CDR |rhs|))
+ NIL)))
+ (#1#
+ (PROGN
+ (SETQ |l2|
+ (|bfLET2| |var2|
+ (|addCARorCDR| 'CDR |rhs|)))
+ (COND
+ ((AND (CONSP |l2|) (ATOM (CAR |l2|)))
+ (SETQ |l2| (CONS |l2| NIL))))
+ (APPEND |l1| |l2|)))))))))))
+ ((AND (CONSP |lhs|) (EQ (CAR |lhs|) 'APPEND)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |lhs|))
+ (AND (CONSP |ISTMP#1|)
+ (PROGN
+ (SETQ |var1| (CAR |ISTMP#1|))
+ (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+ (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+ (PROGN (SETQ |var2| (CAR |ISTMP#2|)) #0#))))))
+ (PROGN
+ (SETQ |patrev| (|bfISReverse| |var2| |var1|))
+ (SETQ |rev| (LIST 'REVERSE |rhs|))
+ (SETQ |g|
+ (INTERN (CONCAT "LETTMP#"
+ (STRINGIMAGE |$letGenVarCounter|))))
+ (SETQ |$letGenVarCounter| (+ |$letGenVarCounter| 1))
+ (SETQ |l2| (|bfLET2| |patrev| |g|))
+ (COND
+ ((AND (CONSP |l2|) (ATOM (CAR |l2|)))
+ (SETQ |l2| (CONS |l2| NIL))))
+ (COND
+ ((EQ |var1| 'DOT) (CONS (LIST 'L%T |g| |rev|) |l2|))
+ ((PROGN
+ (SETQ |ISTMP#1| (|last| |l2|))
+ (AND (CONSP |ISTMP#1|) (EQ (CAR |ISTMP#1|) 'L%T)
+ (PROGN
+ (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+ (AND (CONSP |ISTMP#2|)
+ (EQUAL (CAR |ISTMP#2|) |var1|)
+ (PROGN
+ (SETQ |ISTMP#3| (CDR |ISTMP#2|))
+ (AND (CONSP |ISTMP#3|)
+ (EQ (CDR |ISTMP#3|) NIL)
+ (PROGN
+ (SETQ |val1| (CAR |ISTMP#3|))
+ #0#)))))))
+ (CONS (LIST 'L%T |g| |rev|)
+ (APPEND (REVERSE (CDR (REVERSE |l2|)))
+ (CONS (|bfLetForm| |var1|
+ (LIST 'NREVERSE |val1|))
+ NIL))))
+ (#1#
+ (CONS (LIST 'L%T |g| |rev|)
+ (APPEND |l2|
+ (CONS (|bfLetForm| |var1|
+ (LIST 'NREVERSE |var1|))
+ NIL)))))))
+ ((AND (CONSP |lhs|) (EQ (CAR |lhs|) 'EQUAL)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |lhs|))
+ (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+ (PROGN (SETQ |var1| (CAR |ISTMP#1|)) #0#))))
+ (LIST 'COND (LIST (LIST 'EQUAL |var1| |rhs|) |var1|)))
+ (#1#
+ (PROGN
+ (SETQ |isPred|
+ (COND
+ (|$inDefIS| (|bfIS1| |rhs| |lhs|))
+ (#1# (|bfIS| |rhs| |lhs|))))
+ (LIST 'COND (LIST |isPred| |rhs|))))))))
+
+(DEFUN |bfLET| (|lhs| |rhs|)
+ (PROG (|$letGenVarCounter|)
+ (DECLARE (SPECIAL |$letGenVarCounter|))
+ (RETURN
+ (PROGN (SETQ |$letGenVarCounter| 1) (|bfLET1| |lhs| |rhs|)))))
+
+(DEFUN |addCARorCDR| (|acc| |expr|)
+ (PROG (|funsR| |funsA| |p| |funs|)
+ (RETURN
+ (COND
+ ((NULL (CONSP |expr|)) (LIST |acc| |expr|))
+ ((AND (EQ |acc| 'CAR) (EQCAR |expr| 'REVERSE))
+ (LIST 'CAR (CONS 'LAST (CDR |expr|))))
+ (#0='T
+ (PROGN
+ (SETQ |funs|
+ '(CAR CDR CAAR CDAR CADR CDDR CAAAR CADAR CAADR CADDR
+ CDAAR CDDAR CDADR CDDDR))
+ (SETQ |p| (|bfPosition| (CAR |expr|) |funs|))
+ (COND
+ ((EQUAL |p| (- 1)) (LIST |acc| |expr|))
+ (#0#
+ (PROGN
+ (SETQ |funsA|
+ '(CAAR CADR CAAAR CADAR CAADR CADDR CAAAAR CAADAR
+ CAAADR CAADDR CADAAR CADDAR CADADR CADDDR))
+ (SETQ |funsR|
+ '(CDAR CDDR CDAAR CDDAR CDADR CDDDR CDAAAR CDADAR
+ CDAADR CDADDR CDDAAR CDDDAR CDDADR CDDDDR))
+ (COND
+ ((EQ |acc| 'CAR)
+ (CONS (ELT |funsA| |p|) (CDR |expr|)))
+ ('T (CONS (ELT |funsR| |p|) (CDR |expr|)))))))))))))
+
+(DEFUN |bfPosition| (|x| |l|) (PROG () (RETURN (|bfPosn| |x| |l| 0))))
+
+(DEFUN |bfPosn| (|x| |l| |n|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((NULL |l|) (- 1))
+ ((EQUAL |x| (CAR |l|)) |n|)
+ ('T (|bfPosn| |x| (CDR |l|) (+ |n| 1)))))))
+
+(DEFUN |bfISApplication| (|op| |left| |right|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((EQ |op| 'IS) (|bfIS| |left| |right|))
+ ((EQ |op| 'ISNT) (|bfNOT| (|bfIS| |left| |right|)))
+ ('T (LIST |op| |left| |right|))))))
+
+(DEFUN |bfIS| (|left| |right|)
+ (PROG (|$inDefIS| |$isGenVarCounter|)
+ (DECLARE (SPECIAL |$inDefIS| |$isGenVarCounter|))
+ (RETURN
+ (PROGN
+ (SETQ |$isGenVarCounter| 1)
+ (SETQ |$inDefIS| T)
+ (|bfIS1| |left| |right|)))))
+
+(DEFUN |bfISReverse| (|x| |a|)
+ (PROG (|y|)
+ (RETURN
+ (COND
+ ((AND (CONSP |x|) (EQ (CAR |x|) 'CONS))
+ (COND
+ ((NULL (CADDR |x|)) (LIST 'CONS (CADR |x|) |a|))
+ (#0='T
+ (PROGN
+ (SETQ |y| (|bfISReverse| (CADDR |x|) NIL))
+ (RPLACA (CDDR |y|) (LIST 'CONS (CADR |x|) |a|))
+ |y|))))
+ (#0#
+ (PROGN
+ (|bpSpecificErrorHere| "Error in bfISReverse")
+ (|bpTrap|)))))))
+
+(DEFUN |bfIS1| (|lhs| |rhs|)
+ (PROG (|l2| |rev| |patrev| |cls| |b1| |a1| |b| |g| |l| |d| |ISTMP#2|
+ |c| |a| |ISTMP#1|)
+ (DECLARE (SPECIAL |$isGenVarCounter|))
+ (RETURN
+ (COND
+ ((NULL |rhs|) (LIST 'NULL |lhs|))
+ ((STRINGP |rhs|) (LIST 'EQ |lhs| (LIST 'QUOTE (INTERN |rhs|))))
+ ((NUMBERP |rhs|) (LIST 'EQUAL |lhs| |rhs|))
+ ((ATOM |rhs|) (LIST 'PROGN (|bfLetForm| |rhs| |lhs|) ''T))
+ ((AND (CONSP |rhs|) (EQ (CAR |rhs|) 'QUOTE)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |rhs|))
+ (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+ (PROGN (SETQ |a| (CAR |ISTMP#1|)) #0='T))))
+ (COND
+ ((IDENTP |a|) (LIST 'EQ |lhs| |rhs|))
+ (#1='T (LIST 'EQUAL |lhs| |rhs|))))
+ ((AND (CONSP |rhs|) (EQ (CAR |rhs|) 'L%T)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |rhs|))
+ (AND (CONSP |ISTMP#1|)
+ (PROGN
+ (SETQ |c| (CAR |ISTMP#1|))
+ (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+ (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+ (PROGN (SETQ |d| (CAR |ISTMP#2|)) #0#))))))
+ (PROGN
+ (SETQ |l| (|bfLET| |c| |lhs|))
+ (|bfAND| (LIST (|bfIS1| |lhs| |d|)
+ (|bfMKPROGN| (LIST |l| ''T))))))
+ ((AND (CONSP |rhs|) (EQ (CAR |rhs|) 'EQUAL)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |rhs|))
+ (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+ (PROGN (SETQ |a| (CAR |ISTMP#1|)) #0#))))
+ (LIST 'EQUAL |lhs| |a|))
+ ((CONSP |lhs|)
+ (PROGN
+ (SETQ |g|
+ (INTERN (CONCAT "ISTMP#"
+ (STRINGIMAGE |$isGenVarCounter|))))
+ (SETQ |$isGenVarCounter| (+ |$isGenVarCounter| 1))
+ (|bfMKPROGN|
+ (LIST (LIST 'L%T |g| |lhs|) (|bfIS1| |g| |rhs|)))))
+ ((AND (CONSP |rhs|) (EQ (CAR |rhs|) 'CONS)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |rhs|))
+ (AND (CONSP |ISTMP#1|)
+ (PROGN
+ (SETQ |a| (CAR |ISTMP#1|))
+ (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+ (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+ (PROGN (SETQ |b| (CAR |ISTMP#2|)) #0#))))))
+ (COND
+ ((EQ |a| 'DOT)
+ (COND
+ ((NULL |b|)
+ (|bfAND| (LIST (LIST 'CONSP |lhs|)
+ (LIST 'EQ (LIST 'CDR |lhs|) 'NIL))))
+ (#1#
+ (|bfAND| (LIST (LIST 'CONSP |lhs|)
+ (|bfIS1| (LIST 'CDR |lhs|) |b|))))))
+ ((NULL |b|)
+ (|bfAND| (LIST (LIST 'CONSP |lhs|)
+ (LIST 'EQ (LIST 'CDR |lhs|) 'NIL)
+ (|bfIS1| (LIST 'CAR |lhs|) |a|))))
+ ((EQ |b| 'DOT)
+ (|bfAND| (LIST (LIST 'CONSP |lhs|)
+ (|bfIS1| (LIST 'CAR |lhs|) |a|))))
+ (#1#
+ (PROGN
+ (SETQ |a1| (|bfIS1| (LIST 'CAR |lhs|) |a|))
+ (SETQ |b1| (|bfIS1| (LIST 'CDR |lhs|) |b|))
+ (COND
+ ((AND (CONSP |a1|) (EQ (CAR |a1|) 'PROGN)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |a1|))
+ (AND (CONSP |ISTMP#1|)
+ (PROGN
+ (SETQ |c| (CAR |ISTMP#1|))
+ (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+ (AND (CONSP |ISTMP#2|)
+ (EQ (CDR |ISTMP#2|) NIL)
+ (EQUAL (CAR |ISTMP#2|) ''T)))))
+ (CONSP |b1|) (EQ (CAR |b1|) 'PROGN)
+ (PROGN (SETQ |cls| (CDR |b1|)) #0#))
+ (|bfAND| (LIST (LIST 'CONSP |lhs|)
+ (|bfMKPROGN| (CONS |c| |cls|)))))
+ (#1# (|bfAND| (LIST (LIST 'CONSP |lhs|) |a1| |b1|))))))))
+ ((AND (CONSP |rhs|) (EQ (CAR |rhs|) 'APPEND)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |rhs|))
+ (AND (CONSP |ISTMP#1|)
+ (PROGN
+ (SETQ |a| (CAR |ISTMP#1|))
+ (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+ (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+ (PROGN (SETQ |b| (CAR |ISTMP#2|)) #0#))))))
+ (PROGN
+ (SETQ |patrev| (|bfISReverse| |b| |a|))
+ (SETQ |g|
+ (INTERN (CONCAT "ISTMP#"
+ (STRINGIMAGE |$isGenVarCounter|))))
+ (SETQ |$isGenVarCounter| (+ |$isGenVarCounter| 1))
+ (SETQ |rev|
+ (|bfAND| (LIST (LIST 'CONSP |lhs|)
+ (LIST 'PROGN
+ (LIST 'L%T |g|
+ (LIST 'REVERSE |lhs|))
+ ''T))))
+ (SETQ |l2| (|bfIS1| |g| |patrev|))
+ (COND
+ ((AND (CONSP |l2|) (ATOM (CAR |l2|)))
+ (SETQ |l2| (CONS |l2| NIL))))
+ (COND
+ ((EQ |a| 'DOT) (|bfAND| (CONS |rev| |l2|)))
+ (#1#
+ (|bfAND| (CONS |rev|
+ (APPEND |l2|
+ (CONS
+ (LIST 'PROGN
+ (|bfLetForm| |a|
+ (LIST 'NREVERSE |a|))
+ ''T)
+ NIL))))))))
+ (#1#
+ (PROGN
+ (|bpSpecificErrorHere| "bad IS code is generated")
+ (|bpTrap|)))))))
+
+(DEFUN |bfApplication| (|bfop| |bfarg|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((|bfTupleP| |bfarg|) (CONS |bfop| (CDR |bfarg|)))
+ ('T (CONS |bfop| (LIST |bfarg|)))))))
+
+(DEFUN |bfGetOldBootName| (|x|)
+ (PROG (|a|)
+ (RETURN
+ (COND ((SETQ |a| (GET |x| 'OLD-BOOT)) (CAR |a|)) ('T |x|)))))
+
+(DEFUN |bfSameMeaning| (|x|) (PROG () (RETURN (GET |x| 'RENAME-OK))))
+
+(DEFUN |bfReName| (|x|)
+ (PROG (|oldName| |newName| |a|)
+ (DECLARE (SPECIAL |$translatingOldBoot|))
+ (RETURN
+ (PROGN
+ (SETQ |newName|
+ (COND
+ ((SETQ |a| (GET |x| 'SHOERENAME)) (CAR |a|))
+ (#0='T |x|)))
+ (COND
+ ((AND |$translatingOldBoot| (NULL (|bfSameMeaning| |x|)))
+ (PROGN
+ (SETQ |oldName| (|bfGetOldBootName| |x|))
+ (COND
+ ((NOT (EQUAL |newName| |oldName|))
+ (|warn| (LIST (PNAME |x|) " as `" (PNAME |newName|)
+ "' differs from Old Boot `"
+ (PNAME |oldName|) "'"))))
+ |oldName|))
+ (#0# |newName|))))))
+
+(DEFUN |bfInfApplication| (|op| |left| |right|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((EQ |op| 'EQUAL) (|bfQ| |left| |right|))
+ ((EQ |op| '/=) (|bfNOT| (|bfQ| |left| |right|)))
+ ((EQ |op| '>) (|bfLessp| |right| |left|))
+ ((EQ |op| '<) (|bfLessp| |left| |right|))
+ ((EQ |op| '<=) (|bfNOT| (|bfLessp| |right| |left|)))
+ ((EQ |op| '>=) (|bfNOT| (|bfLessp| |left| |right|)))
+ ((EQ |op| 'OR) (|bfOR| (LIST |left| |right|)))
+ ((EQ |op| 'AND) (|bfAND| (LIST |left| |right|)))
+ ('T (LIST |op| |left| |right|))))))
+
+(DEFUN |bfNOT| (|x|)
+ (PROG (|a| |ISTMP#1|)
+ (RETURN
+ (COND
+ ((AND (CONSP |x|) (EQ (CAR |x|) 'NOT)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |x|))
+ (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+ (PROGN (SETQ |a| (CAR |ISTMP#1|)) #0='T))))
+ |a|)
+ ((AND (CONSP |x|) (EQ (CAR |x|) 'NULL)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |x|))
+ (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+ (PROGN (SETQ |a| (CAR |ISTMP#1|)) #0#))))
+ |a|)
+ ('T (LIST 'NOT |x|))))))
+
+(DEFUN |bfFlatten| (|op| |x|)
+ (PROG ()
+ (RETURN (COND ((EQCAR |x| |op|) (CDR |x|)) ('T (LIST |x|))))))
+
+(DEFUN |bfOR| (|l|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((NULL |l|) NIL)
+ ((NULL (CDR |l|)) (CAR |l|))
+ ('T
+ (CONS 'OR
+ (LET ((|bfVar#83| NIL) (|bfVar#82| |l|) (|c| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#82|)
+ (PROGN (SETQ |c| (CAR |bfVar#82|)) NIL))
+ (RETURN (NREVERSE |bfVar#83|)))
+ ('T
+ (SETQ |bfVar#83|
+ (APPEND (REVERSE (|bfFlatten| 'OR |c|))
+ |bfVar#83|))))
+ (SETQ |bfVar#82| (CDR |bfVar#82|))))))))))
+
+(DEFUN |bfAND| (|l|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((NULL |l|) 'T)
+ ((NULL (CDR |l|)) (CAR |l|))
+ ('T
+ (CONS 'AND
+ (LET ((|bfVar#85| NIL) (|bfVar#84| |l|) (|c| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#84|)
+ (PROGN (SETQ |c| (CAR |bfVar#84|)) NIL))
+ (RETURN (NREVERSE |bfVar#85|)))
+ ('T
+ (SETQ |bfVar#85|
+ (APPEND (REVERSE (|bfFlatten| 'AND |c|))
+ |bfVar#85|))))
+ (SETQ |bfVar#84| (CDR |bfVar#84|))))))))))
+
+(DEFUN |defQuoteId| (|x|)
+ (PROG () (RETURN (AND (EQCAR |x| 'QUOTE) (IDENTP (CADR |x|))))))
+
+(DEFUN |bfSmintable| (|x|)
+ (PROG ()
+ (RETURN
+ (OR (INTEGERP |x|)
+ (AND (CONSP |x|) (MEMQ (CAR |x|) '(SIZE LENGTH)))))))
+
+(DEFUN |bfQ| (|l| |r|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((OR (|bfSmintable| |l|) (|bfSmintable| |r|))
+ (LIST 'EQL |l| |r|))
+ ((OR (|defQuoteId| |l|) (|defQuoteId| |r|)) (LIST 'EQ |l| |r|))
+ ((NULL |l|) (LIST 'NULL |r|))
+ ((NULL |r|) (LIST 'NULL |l|))
+ ('T (LIST 'EQUAL |l| |r|))))))
+
+(DEFUN |bfLessp| (|l| |r|)
+ (PROG ()
+ (RETURN
+ (COND ((EQL |r| 0) (LIST 'MINUSP |l|)) ('T (LIST '< |l| |r|))))))
+
+(DEFUN |bfMDef| (|defOp| |op| |args| |body|)
+ (PROG (|def| |lamex| |sb2| |sb| |largl| |nargl| |sgargl| |gargl|
+ |LETTMP#1| |argl|)
+ (DECLARE (SPECIAL |$wheredefs|))
+ (RETURN
+ (PROGN
+ (SETQ |argl|
+ (COND
+ ((|bfTupleP| |args|) (CDR |args|))
+ ('T (LIST |args|))))
+ (SETQ |LETTMP#1| (|bfGargl| |argl|))
+ (SETQ |gargl| (CAR |LETTMP#1|))
+ (SETQ |sgargl| (CADR . #0=(|LETTMP#1|)))
+ (SETQ |nargl| (CADDR . #0#))
+ (SETQ |largl| (CADDDR . #0#))
+ (SETQ |sb|
+ (LET ((|bfVar#88| NIL) (|bfVar#86| |nargl|) (|i| NIL)
+ (|bfVar#87| |sgargl|) (|j| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#86|)
+ (PROGN (SETQ |i| (CAR |bfVar#86|)) NIL)
+ (ATOM |bfVar#87|)
+ (PROGN (SETQ |j| (CAR |bfVar#87|)) NIL))
+ (RETURN (NREVERSE |bfVar#88|)))
+ (#1='T
+ (SETQ |bfVar#88| (CONS (CONS |i| |j|) |bfVar#88|))))
+ (SETQ |bfVar#86| (CDR |bfVar#86|))
+ (SETQ |bfVar#87| (CDR |bfVar#87|)))))
+ (SETQ |body| (SUBLIS |sb| |body|))
+ (SETQ |sb2|
+ (LET ((|bfVar#91| NIL) (|bfVar#89| |sgargl|) (|i| NIL)
+ (|bfVar#90| |largl|) (|j| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#89|)
+ (PROGN (SETQ |i| (CAR |bfVar#89|)) NIL)
+ (ATOM |bfVar#90|)
+ (PROGN (SETQ |j| (CAR |bfVar#90|)) NIL))
+ (RETURN (NREVERSE |bfVar#91|)))
+ (#1#
+ (SETQ |bfVar#91|
+ (CONS (LIST 'CONS (LIST 'QUOTE |i|) |j|)
+ |bfVar#91|))))
+ (SETQ |bfVar#89| (CDR |bfVar#89|))
+ (SETQ |bfVar#90| (CDR |bfVar#90|)))))
+ (SETQ |body|
+ (LIST 'SUBLIS (CONS 'LIST |sb2|) (LIST 'QUOTE |body|)))
+ (SETQ |lamex| (LIST 'MLAMBDA |gargl| |body|))
+ (SETQ |def| (LIST |op| |lamex|))
+ (|bfTuple|
+ (CONS (|shoeComp| |def|)
+ (LET ((|bfVar#93| NIL) (|bfVar#92| |$wheredefs|)
+ (|d| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#92|)
+ (PROGN (SETQ |d| (CAR |bfVar#92|)) NIL))
+ (RETURN (NREVERSE |bfVar#93|)))
+ (#1#
+ (SETQ |bfVar#93|
+ (APPEND (REVERSE
+ (|shoeComps| (|bfDef1| |d|)))
+ |bfVar#93|))))
+ (SETQ |bfVar#92| (CDR |bfVar#92|))))))))))
+
+(DEFUN |bfGargl| (|argl|)
+ (PROG (|f| |d| |c| |b| |a| |LETTMP#1|)
+ (RETURN
+ (COND
+ ((NULL |argl|) (LIST NIL NIL NIL NIL))
+ (#0='T (SETQ |LETTMP#1| (|bfGargl| (CDR |argl|)))
+ (SETQ |a| (CAR |LETTMP#1|))
+ (SETQ |b| (CADR . #1=(|LETTMP#1|))) (SETQ |c| (CADDR . #1#))
+ (SETQ |d| (CADDDR . #1#))
+ (COND
+ ((EQ (CAR |argl|) '&REST)
+ (LIST (CONS (CAR |argl|) |b|) |b| |c|
+ (CONS (LIST 'CONS (LIST 'QUOTE 'LIST) (CAR |d|))
+ (CDR |d|))))
+ (#0# (SETQ |f| (|bfGenSymbol|))
+ (LIST (CONS |f| |a|) (CONS |f| |b|) (CONS (CAR |argl|) |c|)
+ (CONS |f| |d|)))))))))
+
+(DEFUN |bfDef1| (|bfVar#94|)
+ (PROG (|arglp| |control| |quotes| |LETTMP#1| |argl| |body| |args|
+ |op| |defOp|)
+ (RETURN
+ (PROGN
+ (SETQ |defOp| (CAR |bfVar#94|))
+ (SETQ |op| (CADR . #0=(|bfVar#94|)))
+ (SETQ |args| (CADDR . #0#))
+ (SETQ |body| (CADDDR . #0#))
+ (SETQ |argl|
+ (COND
+ ((|bfTupleP| |args|) (CDR |args|))
+ ('T (LIST |args|))))
+ (SETQ |LETTMP#1| (|bfInsertLet| |argl| |body|))
+ (SETQ |quotes| (CAR |LETTMP#1|))
+ (SETQ |control| (CADR . #1=(|LETTMP#1|)))
+ (SETQ |arglp| (CADDR . #1#))
+ (SETQ |body| (CADDDR . #1#))
+ (COND
+ (|quotes| (|shoeLAM| |op| |arglp| |control| |body|))
+ ('T (LIST (LIST |op| (LIST 'LAMBDA |arglp| |body|)))))))))
+
+(DEFUN |shoeLAM| (|op| |args| |control| |body|)
+ (PROG (|innerfunc| |margs|)
+ (RETURN
+ (PROGN
+ (SETQ |margs| (|bfGenSymbol|))
+ (SETQ |innerfunc| (INTERN (CONCAT (PNAME |op|) '|,LAM|)))
+ (LIST (LIST |innerfunc| (LIST 'LAMBDA |args| |body|))
+ (LIST |op|
+ (LIST 'MLAMBDA (LIST '&REST |margs|)
+ (LIST 'CONS (LIST 'QUOTE |innerfunc|)
+ (LIST 'WRAP |margs|
+ (LIST 'QUOTE |control|))))))))))
+
+(DEFUN |bfDef| (|defOp| |op| |args| |body|)
+ (PROG (|body1| |arg1| |op1| |LETTMP#1|)
+ (DECLARE (SPECIAL |$wheredefs| |$bfClamming|))
+ (RETURN
+ (COND
+ (|$bfClamming|
+ (PROGN
+ (SETQ |LETTMP#1|
+ (|shoeComp|
+ (CAR (|bfDef1|
+ (LIST |defOp| |op| |args| |body|)))))
+ (SETQ |op1| (CADR . #0=(|LETTMP#1|)))
+ (SETQ |arg1| (CADDR . #0#))
+ (SETQ |body1| (CDDDR . #0#))
+ (|bfCompHash| |op1| |arg1| |body1|)))
+ ('T
+ (|bfTuple|
+ (LET ((|bfVar#96| NIL)
+ (|bfVar#95|
+ (CONS (LIST |defOp| |op| |args| |body|)
+ |$wheredefs|))
+ (|d| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#95|)
+ (PROGN (SETQ |d| (CAR |bfVar#95|)) NIL))
+ (RETURN (NREVERSE |bfVar#96|)))
+ ('T
+ (SETQ |bfVar#96|
+ (APPEND (REVERSE (|shoeComps| (|bfDef1| |d|)))
+ |bfVar#96|))))
+ (SETQ |bfVar#95| (CDR |bfVar#95|))))))))))
+
+(DEFUN |shoeComps| (|x|)
+ (PROG ()
+ (RETURN
+ (LET ((|bfVar#98| NIL) (|bfVar#97| |x|) (|def| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#97|)
+ (PROGN (SETQ |def| (CAR |bfVar#97|)) NIL))
+ (RETURN (NREVERSE |bfVar#98|)))
+ ('T (SETQ |bfVar#98| (CONS (|shoeComp| |def|) |bfVar#98|))))
+ (SETQ |bfVar#97| (CDR |bfVar#97|)))))))
+
+(DEFUN |shoeComp| (|x|)
+ (PROG (|a|)
+ (RETURN
+ (PROGN
+ (SETQ |a| (|shoeCompTran| (CADR |x|)))
+ (COND
+ ((EQCAR |a| 'LAMBDA)
+ (CONS 'DEFUN (CONS (CAR |x|) (CONS (CADR |a|) (CDDR |a|)))))
+ ('T
+ (CONS 'DEFMACRO
+ (CONS (CAR |x|) (CONS (CADR |a|) (CDDR |a|))))))))))
+
+(DEFUN |bfInsertLet| (|x| |body|)
+ (PROG (|body2| |name2| |norq1| |b1| |body1| |name1| |norq| |LETTMP#1|
+ |b| |a| |ISTMP#1|)
+ (RETURN
+ (COND
+ ((NULL |x|) (LIST NIL NIL |x| |body|))
+ ((AND (CONSP |x|) (EQ (CAR |x|) '&REST)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |x|))
+ (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+ (PROGN (SETQ |a| (CAR |ISTMP#1|)) #0='T))))
+ (COND
+ ((AND (CONSP |a|) (EQ (CAR |a|) 'QUOTE)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |a|))
+ (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+ (PROGN (SETQ |b| (CAR |ISTMP#1|)) #0#))))
+ (LIST T 'QUOTE (LIST '&REST |b|) |body|))
+ (#1='T (LIST NIL NIL |x| |body|))))
+ (#1# (SETQ |LETTMP#1| (|bfInsertLet1| (CAR |x|) |body|))
+ (SETQ |b| (CAR |LETTMP#1|))
+ (SETQ |norq| (CADR . #2=(|LETTMP#1|)))
+ (SETQ |name1| (CADDR . #2#)) (SETQ |body1| (CADDDR . #2#))
+ (SETQ |LETTMP#1| (|bfInsertLet| (CDR |x|) |body1|))
+ (SETQ |b1| (CAR |LETTMP#1|))
+ (SETQ |norq1| (CADR . #3=(|LETTMP#1|)))
+ (SETQ |name2| (CADDR . #3#)) (SETQ |body2| (CADDDR . #3#))
+ (LIST (OR |b| |b1|) (CONS |norq| |norq1|)
+ (CONS |name1| |name2|) |body2|))))))
+
+(DEFUN |bfInsertLet1| (|y| |body|)
+ (PROG (|g| |b| |r| |ISTMP#2| |l| |ISTMP#1|)
+ (RETURN
+ (COND
+ ((AND (CONSP |y|) (EQ (CAR |y|) 'L%T)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |y|))
+ (AND (CONSP |ISTMP#1|)
+ (PROGN
+ (SETQ |l| (CAR |ISTMP#1|))
+ (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+ (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+ (PROGN (SETQ |r| (CAR |ISTMP#2|)) #0='T))))))
+ (LIST NIL NIL |l|
+ (|bfMKPROGN| (LIST (|bfLET| |r| |l|) |body|))))
+ ((IDENTP |y|) (LIST NIL NIL |y| |body|))
+ ((AND (CONSP |y|) (EQ (CAR |y|) 'BVQUOTE)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |y|))
+ (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+ (PROGN (SETQ |b| (CAR |ISTMP#1|)) #0#))))
+ (LIST T 'QUOTE |b| |body|))
+ ('T (SETQ |g| (|bfGenSymbol|))
+ (COND
+ ((ATOM |y|) (LIST NIL NIL |g| |body|))
+ ('T
+ (LIST NIL NIL |g|
+ (|bfMKPROGN|
+ (LIST (|bfLET| (|compFluidize| |y|) |g|) |body|))))))))))
+
+(DEFUN |shoeCompTran| (|x|)
+ (PROG (|$dollarVars| |$locVars| |$fluidVars| |fvs| |fl| |fvars|
+ |lvars| |body| |args| |lamtype|)
+ (DECLARE (SPECIAL |$typings| |$dollarVars| |$fluidVars| |$locVars|))
+ (RETURN
+ (PROGN
+ (SETQ |lamtype| (CAR |x|))
+ (SETQ |args| (CADR |x|))
+ (SETQ |body| (CDDR |x|))
+ (SETQ |$fluidVars| NIL)
+ (SETQ |$locVars| NIL)
+ (SETQ |$dollarVars| NIL)
+ (|shoeCompTran1| |body|)
+ (SETQ |$locVars|
+ (SETDIFFERENCE (SETDIFFERENCE |$locVars| |$fluidVars|)
+ (|shoeATOMs| |args|)))
+ (SETQ |body|
+ (COND
+ ((OR |$fluidVars| |$locVars| |$dollarVars| |$typings|)
+ (SETQ |lvars| (APPEND |$fluidVars| |$locVars|))
+ (SETQ |$fluidVars| (UNION |$fluidVars| |$dollarVars|))
+ (COND
+ ((NULL |$fluidVars|)
+ (COND
+ ((NULL |$typings|) (|shoePROG| |lvars| |body|))
+ (#0='T
+ (|shoePROG| |lvars|
+ (CONS (CONS 'DECLARE |$typings|) |body|)))))
+ (#1='T
+ (SETQ |fvars|
+ (LIST 'DECLARE (CONS 'SPECIAL |$fluidVars|)))
+ (COND
+ ((NULL |$typings|)
+ (|shoePROG| |lvars| (CONS |fvars| |body|)))
+ (#0#
+ (|shoePROG| |lvars|
+ (CONS |fvars|
+ (CONS (CONS 'DECLARE |$typings|)
+ |body|))))))))
+ (#1# (|shoePROG| NIL |body|))))
+ (SETQ |fl| (|shoeFluids| |args|))
+ (SETQ |body|
+ (COND
+ (|fl| (SETQ |fvs| (LIST 'DECLARE (CONS 'SPECIAL |fl|)))
+ (CONS |fvs| |body|))
+ (#1# |body|)))
+ (CONS |lamtype| (CONS |args| |body|))))))
+
+(DEFUN |shoePROG| (|v| |b|)
+ (PROG (|blist| |blast| |LETTMP#1|)
+ (RETURN
+ (COND
+ ((NULL |b|) (LIST (LIST 'PROG |v|)))
+ ('T
+ (PROGN
+ (SETQ |LETTMP#1| (REVERSE |b|))
+ (SETQ |blast| (CAR |LETTMP#1|))
+ (SETQ |blist| (NREVERSE (CDR |LETTMP#1|)))
+ (LIST (CONS 'PROG
+ (CONS |v|
+ (APPEND |blist|
+ (CONS (LIST 'RETURN |blast|) NIL)))))))))))
+
+(DEFUN |shoeFluids| (|x|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((NULL |x|) NIL)
+ ((AND (IDENTP |x|) (|bfBeginsDollar| |x|)) (LIST |x|))
+ ((EQCAR |x| 'QUOTE) NIL)
+ ((ATOM |x|) NIL)
+ ('T (APPEND (|shoeFluids| (CAR |x|)) (|shoeFluids| (CDR |x|))))))))
+
+(DEFUN |shoeATOMs| (|x|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((NULL |x|) NIL)
+ ((ATOM |x|) (LIST |x|))
+ ('T (APPEND (|shoeATOMs| (CAR |x|)) (|shoeATOMs| (CDR |x|))))))))
+
+(DEFUN |shoeCompTran1| (|x|)
+ (PROG (|res| |newbindings| |r| |ISTMP#2| |l| |ISTMP#1| U)
+ (DECLARE (SPECIAL |$fluidVars| |$locVars| |$dollarVars|))
+ (RETURN
+ (COND
+ ((ATOM |x|)
+ (COND
+ ((AND (IDENTP |x|) (|bfBeginsDollar| |x|))
+ (SETQ |$dollarVars|
+ (COND
+ ((MEMQ |x| |$dollarVars|) |$dollarVars|)
+ (#0='T (CONS |x| |$dollarVars|)))))
+ (#0# NIL)))
+ (#0#
+ (PROGN
+ (SETQ U (CAR |x|))
+ (COND
+ ((EQ U 'QUOTE) NIL)
+ ((AND (CONSP |x|) (EQ (CAR |x|) 'L%T)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |x|))
+ (AND (CONSP |ISTMP#1|)
+ (PROGN
+ (SETQ |l| (CAR |ISTMP#1|))
+ (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+ (AND (CONSP |ISTMP#2|)
+ (EQ (CDR |ISTMP#2|) NIL)
+ (PROGN (SETQ |r| (CAR |ISTMP#2|)) 'T))))))
+ (PROGN
+ (RPLACA |x| 'SETQ)
+ (|shoeCompTran1| |r|)
+ (COND
+ ((IDENTP |l|)
+ (COND
+ ((NULL (|bfBeginsDollar| |l|))
+ (SETQ |$locVars|
+ (COND
+ ((MEMQ |l| |$locVars|) |$locVars|)
+ (#0# (CONS |l| |$locVars|)))))
+ (#0#
+ (SETQ |$dollarVars|
+ (COND
+ ((MEMQ |l| |$dollarVars|) |$dollarVars|)
+ (#0# (CONS |l| |$dollarVars|)))))))
+ ((EQCAR |l| 'FLUID)
+ (PROGN
+ (SETQ |$fluidVars|
+ (COND
+ ((MEMQ (CADR |l|) |$fluidVars|)
+ |$fluidVars|)
+ (#0# (CONS (CADR |l|) |$fluidVars|))))
+ (RPLACA (CDR |x|) (CADR |l|)))))))
+ ((MEMQ U '(PROG LAMBDA))
+ (PROGN
+ (SETQ |newbindings| NIL)
+ (LET ((|bfVar#99| (CADR |x|)) (|y| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#99|)
+ (PROGN (SETQ |y| (CAR |bfVar#99|)) NIL))
+ (RETURN NIL))
+ (#1='T
+ (COND
+ ((NULL (MEMQ |y| |$locVars|))
+ (IDENTITY
+ (PROGN
+ (SETQ |$locVars| (CONS |y| |$locVars|))
+ (SETQ |newbindings|
+ (CONS |y| |newbindings|))))))))
+ (SETQ |bfVar#99| (CDR |bfVar#99|))))
+ (SETQ |res| (|shoeCompTran1| (CDDR |x|)))
+ (SETQ |$locVars|
+ (LET ((|bfVar#101| NIL) (|bfVar#100| |$locVars|)
+ (|y| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#100|)
+ (PROGN
+ (SETQ |y| (CAR |bfVar#100|))
+ NIL))
+ (RETURN (NREVERSE |bfVar#101|)))
+ (#1#
+ (AND (NULL (MEMQ |y| |newbindings|))
+ (SETQ |bfVar#101|
+ (CONS |y| |bfVar#101|)))))
+ (SETQ |bfVar#100| (CDR |bfVar#100|)))))))
+ (#0#
+ (PROGN
+ (|shoeCompTran1| (CAR |x|))
+ (|shoeCompTran1| (CDR |x|)))))))))))
+
+(DEFUN |bfTagged| (|a| |b|)
+ (PROG ()
+ (DECLARE (SPECIAL |$typings|))
+ (RETURN
+ (COND
+ ((IDENTP |a|)
+ (COND
+ ((EQ |b| 'FLUID) (|bfLET| (|compFluid| |a|) NIL))
+ ((EQ |b| '|fluid|) (|bfLET| (|compFluid| |a|) NIL))
+ ((EQ |b| '|local|) (|bfLET| (|compFluid| |a|) NIL))
+ (#0='T
+ (PROGN
+ (SETQ |$typings| (CONS (LIST 'TYPE |b| |a|) |$typings|))
+ |a|))))
+ (#0# (LIST 'THE |b| |a|))))))
+
+(DEFUN |bfAssign| (|l| |r|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((|bfTupleP| |l|) (|bfSetelt| (CADR |l|) (CDDR |l|) |r|))
+ ('T (|bfLET| |l| |r|))))))
+
+(DEFUN |bfSetelt| (|e| |l| |r|)
+ (PROG ()
+ (RETURN
+ (COND
+ ((NULL (CDR |l|)) (|defSETELT| |e| (CAR |l|) |r|))
+ ('T (|bfSetelt| (|bfElt| |e| (CAR |l|)) (CDR |l|) |r|))))))
+
+(DEFUN |bfElt| (|expr| |sel|)
+ (PROG (|y|)
+ (RETURN
+ (PROGN
+ (SETQ |y| (AND (SYMBOLP |sel|) (GET |sel| 'SHOESELFUNCTION)))
+ (COND
+ (|y| (COND
+ ((INTEGERP |y|) (LIST 'ELT |expr| |y|))
+ (#0='T (LIST |y| |expr|))))
+ (#0# (LIST 'ELT |expr| |sel|)))))))
+
+(DEFUN |defSETELT| (|var| |sel| |expr|)
+ (PROG (|y|)
+ (RETURN
+ (PROGN
+ (SETQ |y| (AND (SYMBOLP |sel|) (GET |sel| 'SHOESELFUNCTION)))
+ (COND
+ (|y| (COND
+ ((INTEGERP |y|)
+ (LIST 'SETF (LIST 'ELT |var| |y|) |expr|))
+ (#0='T (LIST 'SETF (LIST |y| |var|) |expr|))))
+ (#0# (LIST 'SETF (LIST 'ELT |var| |sel|) |expr|)))))))
+
+(DEFUN |bfIfThenOnly| (|a| |b|)
+ (PROG (|b1|)
+ (RETURN
+ (PROGN
+ (SETQ |b1|
+ (COND ((EQCAR |b| 'PROGN) (CDR |b|)) ('T (LIST |b|))))
+ (LIST 'COND (CONS |a| |b1|))))))
+
+(DEFUN |bfIf| (|a| |b| |c|)
+ (PROG (|c1| |b1|)
+ (RETURN
+ (PROGN
+ (SETQ |b1|
+ (COND ((EQCAR |b| 'PROGN) (CDR |b|)) (#0='T (LIST |b|))))
+ (COND
+ ((EQCAR |c| 'COND)
+ (CONS 'COND (CONS (CONS |a| |b1|) (CDR |c|))))
+ ('T
+ (PROGN
+ (SETQ |c1|
+ (COND
+ ((EQCAR |c| 'PROGN) (CDR |c|))
+ (#0# (LIST |c|))))
+ (LIST 'COND (CONS |a| |b1|) (CONS ''T |c1|)))))))))
+
+(DEFUN |bfExit| (|a| |b|)
+ (PROG () (RETURN (LIST 'COND (LIST |a| (LIST 'IDENTITY |b|))))))
+
+(DEFUN |bfMKPROGN| (|l|)
+ (PROG (|a|)
+ (RETURN
+ (PROGN
+ (SETQ |a|
+ (LET ((|bfVar#102| NIL) (|c| |l|))
+ (LOOP
+ (COND
+ ((ATOM |c|) (RETURN (NREVERSE |bfVar#102|)))
+ ('T
+ (SETQ |bfVar#102|
+ (APPEND (REVERSE (|bfFlattenSeq| |c|))
+ |bfVar#102|))))
+ (SETQ |c| (CDR |c|)))))
+ (COND
+ ((NULL |a|) NIL)
+ ((NULL (CDR |a|)) (CAR |a|))
+ ('T (CONS 'PROGN |a|)))))))
+
+(DEFUN |bfFlattenSeq| (|x|)
+ (PROG (|f|)
+ (RETURN
+ (COND
+ ((NULL |x|) NIL)
+ (#0='T
+ (PROGN
+ (SETQ |f| (CAR |x|))
+ (COND
+ ((ATOM |f|) (COND ((CDR |x|) NIL) ('T (LIST |f|))))
+ ((EQCAR |f| 'PROGN)
+ (COND
+ ((CDR |x|)
+ (LET ((|bfVar#104| NIL) (|bfVar#103| (CDR |f|))
+ (|i| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#103|)
+ (PROGN (SETQ |i| (CAR |bfVar#103|)) NIL))
+ (RETURN (NREVERSE |bfVar#104|)))
+ ('T
+ (AND (NULL (ATOM |i|))
+ (SETQ |bfVar#104| (CONS |i| |bfVar#104|)))))
+ (SETQ |bfVar#103| (CDR |bfVar#103|)))))
+ (#0# (CDR |f|))))
+ (#0# (LIST |f|)))))))))
+
+(DEFUN |bfSequence| (|l|)
+ (PROG (|f| |aft| |before| |no| |transform| |b| |ISTMP#5| |ISTMP#4|
+ |ISTMP#3| |a| |ISTMP#2| |ISTMP#1|)
+ (RETURN
+ (COND
+ ((NULL |l|) NIL)
+ (#0='T
+ (PROGN
+ (SETQ |transform|
+ (LET ((|bfVar#106| NIL) (|bfVar#105| |l|) (|x| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#105|)
+ (PROGN (SETQ |x| (CAR |bfVar#105|)) NIL)
+ (NOT (AND (CONSP |x|) (EQ (CAR |x|) 'COND)
+ (PROGN
+ (SETQ |ISTMP#1| (CDR |x|))
+ (AND (CONSP |ISTMP#1|)
+ (EQ (CDR |ISTMP#1|) NIL)
+ (PROGN
+ (SETQ |ISTMP#2|
+ (CAR |ISTMP#1|))
+ (AND (CONSP |ISTMP#2|)
+ (PROGN
+ (SETQ |a|
+ (CAR |ISTMP#2|))
+ (SETQ |ISTMP#3|
+ (CDR |ISTMP#2|))
+ (AND (CONSP |ISTMP#3|)
+ (EQ (CDR |ISTMP#3|) NIL)
+ (PROGN
+ (SETQ |ISTMP#4|
+ (CAR |ISTMP#3|))
+ (AND (CONSP |ISTMP#4|)
+ (EQ (CAR |ISTMP#4|)
+ 'IDENTITY)
+ (PROGN
+ (SETQ |ISTMP#5|
+ (CDR |ISTMP#4|))
+ (AND
+ (CONSP |ISTMP#5|)
+ (EQ
+ (CDR |ISTMP#5|)
+ NIL)
+ (PROGN
+ (SETQ |b|
+ (CAR |ISTMP#5|))
+ 'T))))))))))))))
+ (RETURN (NREVERSE |bfVar#106|)))
+ ('T
+ (SETQ |bfVar#106|
+ (CONS (LIST |a| |b|) |bfVar#106|))))
+ (SETQ |bfVar#105| (CDR |bfVar#105|)))))
+ (SETQ |no| (LENGTH |transform|))
+ (SETQ |before| (|bfTake| |no| |l|))
+ (SETQ |aft| (|bfDrop| |no| |l|))
+ (COND
+ ((NULL |before|)
+ (COND
+ ((NULL (CDR |l|))
+ (PROGN
+ (SETQ |f| (CAR |l|))
+ (COND
+ ((EQCAR |f| 'PROGN) (|bfSequence| (CDR |f|)))
+ ('T |f|))))
+ (#0#
+ (|bfMKPROGN|
+ (LIST (CAR |l|) (|bfSequence| (CDR |l|)))))))
+ ((NULL |aft|) (CONS 'COND |transform|))
+ (#0#
+ (CONS 'COND
+ (APPEND |transform|
+ (CONS (LIST ''T (|bfSequence| |aft|)) NIL)))))))))))
+
+(DEFUN |bfWhere| (|context| |expr|)
+ (PROG (|a| |body| |ISTMP#3| |args| |ISTMP#2| |op| |ISTMP#1| |def|
+ |nondefs| |defs| |opassoc| |LETTMP#1|)
+ (DECLARE (SPECIAL |$wheredefs|))
+ (RETURN
+ (PROGN
+ (SETQ |LETTMP#1| (|defSheepAndGoats| |context|))
+ (SETQ |opassoc| (CAR |LETTMP#1|))
+ (SETQ |defs| (CADR . #0=(|LETTMP#1|)))
+ (SETQ |nondefs| (CADDR . #0#))
+ (SETQ |a|
+ (LET ((|bfVar#108| NIL) (|bfVar#107| |defs|) (|d| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#107|)
+ (PROGN (SETQ |d| (CAR |bfVar#107|)) NIL))
+ (RETURN (NREVERSE |bfVar#108|)))
+ ('T
+ (AND (CONSP |d|)
+ (PROGN
+ (SETQ |def| (CAR |d|))
+ (SETQ |ISTMP#1| (CDR |d|))
+ (AND (CONSP |ISTMP#1|)
+ (PROGN
+ (SETQ |op| (CAR |ISTMP#1|))
+ (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+ (AND (CONSP |ISTMP#2|)
+ (PROGN
+ (SETQ |args| (CAR |ISTMP#2|))
+ (SETQ |ISTMP#3| (CDR |ISTMP#2|))
+ (AND (CONSP |ISTMP#3|)
+ (EQ (CDR |ISTMP#3|) NIL)
+ (PROGN
+ (SETQ |body| (CAR |ISTMP#3|))
+ 'T)))))))
+ (SETQ |bfVar#108|
+ (CONS (LIST |def| |op| |args|
+ (|bfSUBLIS| |opassoc| |body|))
+ |bfVar#108|)))))
+ (SETQ |bfVar#107| (CDR |bfVar#107|)))))
+ (SETQ |$wheredefs| (APPEND |a| |$wheredefs|))
+ (|bfMKPROGN|
+ (|bfSUBLIS| |opassoc| (NCONC |nondefs| (LIST |expr|))))))))
+
+(DEFUN |bfReadLisp| (|string|)
+ (PROG () (RETURN (|bfTuple| (|shoeReadLispString| |string| 0)))))
+
+(DEFUN |bfCompHash| (|op| |argl| |body|)
+ (PROG (|computeFunction| |auxfn|)
+ (RETURN
+ (PROGN
+ (SETQ |auxfn| (INTERN (CONCAT (PNAME |op|) ";")))
+ (SETQ |computeFunction|
+ (CONS 'DEFUN (CONS |auxfn| (CONS |argl| |body|))))
+ (|bfTuple| (CONS |computeFunction| (|bfMain| |auxfn| |op|)))))))
+
+(DEFUN |shoeCompileTimeEvaluation| (|x|)
+ (PROG () (RETURN (LIST 'EVAL-WHEN (LIST :COMPILE-TOPLEVEL) |x|))))
+
+(DEFUN |shoeEVALANDFILEACTQ| (|x|)
+ (PROG ()
+ (RETURN (LIST 'EVAL-WHEN (LIST :EXECUTE :LOAD-TOPLEVEL) |x|))))
+
+(DEFUN |bfMain| (|auxfn| |op|)
+ (PROG (|cacheVector| |cacheCountCode| |cacheResetCode| |cacheType|
+ |mainFunction| |codeBody| |thirdPredPair| |putCode|
+ |secondPredPair| |getCode| |g2| |cacheName| |computeValue|
+ |arg| |g1|)
+ (RETURN
+ (PROGN
+ (SETQ |g1| (|bfGenSymbol|))
+ (SETQ |arg| (LIST '&REST |g1|))
+ (SETQ |computeValue|
+ (LIST 'APPLY (LIST 'FUNCTION |auxfn|) |g1|))
+ (SETQ |cacheName| (INTERN (CONCAT (PNAME |op|) ";AL")))
+ (SETQ |g2| (|bfGenSymbol|))
+ (SETQ |getCode| (LIST 'GETHASH |g1| |cacheName|))
+ (SETQ |secondPredPair| (LIST (LIST 'SETQ |g2| |getCode|) |g2|))
+ (SETQ |putCode| (LIST 'SETF |getCode| |computeValue|))
+ (SETQ |thirdPredPair| (LIST ''T |putCode|))
+ (SETQ |codeBody|
+ (LIST 'PROG (LIST |g2|)
+ (LIST 'RETURN
+ (LIST 'COND |secondPredPair| |thirdPredPair|))))
+ (SETQ |mainFunction| (LIST 'DEFUN |op| |arg| |codeBody|))
+ (SETQ |cacheType| '|hash-table|)
+ (SETQ |cacheResetCode|
+ (LIST 'SETQ |cacheName|
+ (LIST 'MAKE-HASHTABLE (LIST 'QUOTE 'UEQUAL))))
+ (SETQ |cacheCountCode| (LIST '|hashCount| |cacheName|))
+ (SETQ |cacheVector|
+ (LIST |op| |cacheName| |cacheType| |cacheResetCode|
+ |cacheCountCode|))
+ (LIST |mainFunction|
+ (|shoeEVALANDFILEACTQ|
+ (LIST 'SETF
+ (LIST 'GET (LIST 'QUOTE |op|)
+ (LIST 'QUOTE '|cacheInfo|))
+ (LIST 'QUOTE |cacheVector|)))
+ (|shoeEVALANDFILEACTQ| |cacheResetCode|))))))
+
+(DEFUN |bfNameOnly| (|x|)
+ (PROG () (RETURN (COND ((EQ |x| '|t|) (LIST 'T)) ('T (LIST |x|))))))
+
+(DEFUN |bfNameArgs| (|x| |y|)
+ (PROG ()
+ (RETURN
+ (PROGN
+ (SETQ |y|
+ (COND ((EQCAR |y| 'TUPLE) (CDR |y|)) ('T (LIST |y|))))
+ (CONS |x| |y|)))))
+
+(DEFUN |bfStruct| (|name| |arglist|)
+ (PROG ()
+ (RETURN
+ (|bfTuple|
+ (LET ((|bfVar#110| NIL) (|bfVar#109| |arglist|) (|i| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#109|)
+ (PROGN (SETQ |i| (CAR |bfVar#109|)) NIL))
+ (RETURN (NREVERSE |bfVar#110|)))
+ ('T
+ (SETQ |bfVar#110|
+ (CONS (|bfCreateDef| |i|) |bfVar#110|))))
+ (SETQ |bfVar#109| (CDR |bfVar#109|))))))))
+
+(DEFUN |bfCreateDef| (|x|)
+ (PROG (|a| |f|)
+ (RETURN
+ (COND
+ ((NULL (CDR |x|)) (SETQ |f| (CAR |x|))
+ (LIST 'SETQ |f| (LIST 'LIST (LIST 'QUOTE |f|))))
+ ('T
+ (SETQ |a|
+ (LET ((|bfVar#112| NIL) (|bfVar#111| (CDR |x|))
+ (|i| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#111|)
+ (PROGN (SETQ |i| (CAR |bfVar#111|)) NIL))
+ (RETURN (NREVERSE |bfVar#112|)))
+ ('T
+ (SETQ |bfVar#112|
+ (CONS (|bfGenSymbol|) |bfVar#112|))))
+ (SETQ |bfVar#111| (CDR |bfVar#111|)))))
+ (LIST 'DEFUN (CAR |x|) |a|
+ (LIST 'CONS (LIST 'QUOTE (CAR |x|)) (CONS 'LIST |a|))))))))
+
+(DEFUN |bfCaseItem| (|x| |y|) (PROG () (RETURN (LIST |x| |y|))))
+
+(DEFUN |bfCase| (|x| |y|)
+ (PROG (|c| |b| |a| |g1| |g|)
+ (RETURN
+ (PROGN
+ (SETQ |g| (|bfGenSymbol|))
+ (SETQ |g1| (|bfGenSymbol|))
+ (SETQ |a| (|bfLET| |g| |x|))
+ (SETQ |b| (|bfLET| |g1| (LIST 'CDR |g|)))
+ (SETQ |c| (|bfCaseItems| |g1| |y|))
+ (|bfMKPROGN|
+ (LIST |a| |b| (CONS 'CASE (CONS (LIST 'CAR |g|) |c|))))))))
+
+(DEFUN |bfCaseItems| (|g| |x|)
+ (PROG (|j| |ISTMP#1| |i|)
+ (RETURN
+ (LET ((|bfVar#115| NIL) (|bfVar#114| |x|) (|bfVar#113| NIL))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#114|)
+ (PROGN (SETQ |bfVar#113| (CAR |bfVar#114|)) NIL))
+ (RETURN (NREVERSE |bfVar#115|)))
+ ('T
+ (AND (CONSP |bfVar#113|)
+ (PROGN
+ (SETQ |i| (CAR |bfVar#113|))
+ (SETQ |ISTMP#1| (CDR |bfVar#113|))
+ (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+ (PROGN (SETQ |j| (CAR |ISTMP#1|)) 'T)))
+ (SETQ |bfVar#115|
+ (CONS (|bfCI| |g| |i| |j|) |bfVar#115|)))))
+ (SETQ |bfVar#114| (CDR |bfVar#114|)))))))
+
+(DEFUN |bfCI| (|g| |x| |y|)
+ (PROG (|b| |a|)
+ (RETURN
+ (PROGN
+ (SETQ |a| (CDR |x|))
+ (COND
+ ((NULL |a|) (LIST (CAR |x|) |y|))
+ ('T
+ (SETQ |b|
+ (LET ((|bfVar#117| NIL) (|bfVar#116| |a|) (|i| NIL)
+ (|j| 0))
+ (LOOP
+ (COND
+ ((OR (ATOM |bfVar#116|)
+ (PROGN (SETQ |i| (CAR |bfVar#116|)) NIL))
+ (RETURN (NREVERSE |bfVar#117|)))
+ ('T
+ (SETQ |bfVar#117|
+ (CONS (LIST |i| (|bfCARCDR| |j| |g|))
+ |bfVar#117|))))
+ (SETQ |bfVar#116| (CDR |bfVar#116|))
+ (SETQ |j| (+ |j| 1)))))
+ (LIST (CAR |x|) (LIST 'LET |b| |y|))))))))
+
+(DEFUN |bfCARCDR| (|n| |g|)
+ (PROG ()
+ (RETURN (LIST (INTERN (CONCAT "CA" (|bfDs| |n|) "R")) |g|))))
+
+(DEFUN |bfDs| (|n|)
+ (PROG ()
+ (RETURN
+ (COND ((EQL |n| 0) "") ('T (CONCAT "D" (|bfDs| (- |n| 1))))))))
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-03 11:12:26 +0000