altos/telegps-v2.0: git ignore make results

[fw/altos] / src / lisp / ao_lisp_const.lisp

diff --git a/src/lisp/ao_lisp_const.lisp b/src/lisp/ao_lisp_const.lisp
index 4dc63bbf8e82c88daf93493c8557f3ba8f159c64..3c8fd21b73165a6c3d2bd95c40b5c73ddec010bb 100644 (file)
--- a/src/lisp/ao_lisp_const.lisp
+++ b/src/lisp/ao_lisp_const.lisp
@@ -46,17 +46,11 @@
                  (list
                   def
                   name
-                  (list
-                   'lambda
-                   args
-                   (cond ((cdr exprs)
-                          (cons progn exprs))
-                         ((car exprs))
-                         )
-                   )
+                  (cons 'lambda (cons args exprs))
                   )
                  )
      )
+
                                        ; basic list accessors
 
 
@@ -75,32 +69,6 @@
 (defun 1+ (x) (+ x 1))
 (defun 1- (x) (- x 1))
 
-                                       ; boolean operators
-
-(def or (lexpr (l)
-              (let ((ret nil))
-                (while l
-                  (cond ((setq ret (car l))
-                         (setq l nil))
-                        ((setq l (cdr l)))))
-                ret
-                )
-              )
-     )
-
-(def and (lexpr (l)
-              (let ((ret t))
-                (while l
-                  (cond ((setq ret (car l))
-                         (setq l (cdr l)))
-                        ((setq ret (setq l nil)))
-                        )
-                  )
-                ret
-                )
-              )
-     )
-
                                        ; define a set of local
                                        ; variables and then evaluate
                                        ; a list of sexprs
@@ -121,69 +89,58 @@
 
 (def let (macro (vars exprs)
                ((lambda (make-names make-exprs make-nils)
-                  (progn
 
                                        ;
                                        ; make the list of names in the let
                                        ;
 
-                    (setq make-names (lambda (vars)
-                                      (cond (vars
-                                             (cons (car (car vars))
-                                                   (make-names (cdr vars))))
-                                            )
-                                      )
-                         )
+                  (setq make-names (lambda (vars)
+                                     (cond (vars
+                                            (cons (car (car vars))
+                                                  (make-names (cdr vars))))
+                                           )
+                                     )
+                        )
 
                                        ; the set of expressions is
                                        ; the list of set expressions
                                        ; pre-pended to the
                                        ; expressions to evaluate
 
-                    (setq make-exprs (lambda (vars exprs)
-                                      (progn
-                                        (cond (vars (cons
-                                                     (list set
-                                                           (list quote
-                                                                 (car (car vars))
-                                                                 )
-                                                           (cadr (car vars))
-                                                           )
-                                                     (make-exprs (cdr vars) exprs)
-                                                     )
-                                                    )
-                                              (exprs)
-                                              )
-                                        )
-                                      )
-                         )
+                  (setq make-exprs (lambda (vars exprs)
+                                     (cond (vars (cons
+                                                  (list set
+                                                        (list quote
+                                                              (car (car vars))
+                                                              )
+                                                        (cadr (car vars))
+                                                        )
+                                                  (make-exprs (cdr vars) exprs)
+                                                  )
+                                                 )
+                                           (exprs)
+                                           )
+                                     )
+                        )
 
                                        ; the parameters to the lambda is a list
                                        ; of nils of the right length
 
-                    (setq make-nils (lambda (vars)
-                                     (cond (vars (cons nil (make-nils (cdr vars))))
-                                           )
-                                     )
-                         )
+                  (setq make-nils (lambda (vars)
+                                    (cond (vars (cons nil (make-nils (cdr vars))))
+                                          )
+                                    )
+                        )
                                        ; prepend the set operations
                                        ; to the expressions
 
-                    (setq exprs (make-exprs vars exprs))
+                  (setq exprs (make-exprs vars exprs))
 
                                        ; build the lambda.
 
-                    (cons
-                     (list
-                      'lambda
-                      (make-names vars)
-                      (cond ((cdr exprs) (cons 'progn exprs))
-                            ((car exprs))
-                            )
-                      )
-                     (make-nils vars)
-                     )
-                    )
+                  (cons (cons 'lambda (cons (make-names vars) exprs))
+                        (make-nils vars)
+                        )
                   )
                 ()
                 ()
@@ -192,9 +149,36 @@
                )
      )
 
-                                       ; run the let macro once to
-                                       ; evaluate all of the internal
-                                       ; macro calls
+                                       ; boolean operators
+
+(def or (lexpr (l)
+              (let ((ret nil))
+                (while l
+                  (cond ((setq ret (car l))
+                         (setq l nil))
+                        ((setq l (cdr l)))))
+                ret
+                )
+              )
+     )
+
+                                       ; execute to resolve macros
+
+(or nil t)
+
+(def and (lexpr (l)
+              (let ((ret t))
+                (while l
+                  (cond ((setq ret (car l))
+                         (setq l (cdr l)))
+                        ((setq ret (setq l nil)))
+                        )
+                  )
+                ret
+                )
+              )
+     )
 
-(let ((let-param 1)))
+                                       ; execute to resolve macros
 
+(and t nil)