X-Git-Url: https://git.distorted.org.uk/~mdw/sod/blobdiff_plain/aa14a4cddcb96b681d5c19a2ec8bad382f43b264..4b8e5c0347115ff30841f1d1e71afe59ecb6c82c:/src/codegen-impl.lisp

diff --git a/src/codegen-impl.lisp b/src/codegen-impl.lisp
index 25413f8..170f4a8 100644
--- a/src/codegen-impl.lisp
+++ b/src/codegen-impl.lisp
@@ -40,7 +40,6 @@
 (defmethod commentify-argument-name ((name temporary-name))
   nil)
 
-(export 'temporary-function)
 (defun temporary-function ()
   "Return a temporary function name."
   (make-instance 'temporary-function
@@ -66,49 +65,44 @@
 
 ;; Compound statements.
 
-(export '(if-inst make-if-inst
-	  while-inst make-while-inst
-	  do-inst make-do-inst
-	  inst-condition inst-consequent inst-alternative inst-body))
+;; HACK: use gensyms for the `condition' slots to avoid leaking the slot
+;; names, since the symbol `condition' actually comes from the `common-lisp'
+;; package.  The `definst' machinery will symbolicate the various associated
+;; methods correctly despite this subterfuge.
 
-(definst if (stream) (condition consequent alternative)
+(definst if (stream :export t) (#1=#:condition consequent alternative)
   (format-compound-statement (stream consequent alternative)
-    (format stream "if (~A)" condition))
+    (format stream "if (~A)" #1#))
   (when alternative
     (format-compound-statement (stream alternative)
       (write-string "else" stream))))
 
-(definst while (stream) (condition body)
+(definst while (stream :export t) (#1=#:condition body)
   (format-compound-statement (stream body)
-    (format stream "while (~A)" condition)))
+    (format stream "while (~A)" #1#)))
 
-(definst do-while (stream) (body condition)
+(definst do-while (stream :export t) (body #1=#:condition)
   (format-compound-statement (stream body :space)
     (write-string "do" stream))
-  (format stream "while (~A);" condition))
+  (format stream "while (~A);" #1#))
 
 ;; Special varargs hacks.
 
-(export '(va-start-inst make-va-start-inst
-	  va-copy-inst make-va-copy-inst
-	  va-end-inst make-va-end-inst
-	  inst-ap inst-arg inst-to inst-from))
-
-(definst va-start (stream) (ap arg)
+(definst va-start (stream :export t) (ap arg)
   (format stream "va_start(~@<~A, ~_~A~:>);" ap arg))
 
-(definst va-copy (stream) (to from)
+(definst va-copy (stream :export t) (to from)
   (format stream "va_copy(~@<~A, ~_~A~:>);" to from))
 
-(definst va-end (stream) (ap)
+(definst va-end (stream :export t) (ap)
   (format stream "va_end(~A);" ap))
 
 ;; Expressions.
 
-(export '(call-inst make-call-inst inst-func inst-args))
-
-(definst call (stream) (func args)
-  (format stream "~A(~@<~{~A~^, ~_~}~:>)" func args))
+;; HACK: use a gensym for the `func' slot to avoid leaking the slot name,
+;; since the symbol `func' is exported from our package.
+(definst call (stream :export t) (#1=#:func args)
+  (format stream "~A(~@<~{~A~^, ~_~}~:>)" #1# args))
 
 ;;;--------------------------------------------------------------------------
 ;;; Code generator objects.
@@ -121,11 +115,11 @@
   (:documentation
    "Base class for code generator state.
 
-   This contains the bare essentials for supporting the EMIT-INST and
-   ENSURE-VAR protocols; see the documentation for those generic functions
+   This contains the bare essentials for supporting the `emit-inst' and
+   `ensure-var' protocols; see the documentation for those generic functions
    for more details.
 
-   This class isn't abstract.  A full CODEGEN object uses instances of this
+   This class isn't abstract.  A full `codegen' object uses instances of this
    to keep track of pending functions which haven't been completed yet.
 
    Just in case that wasn't clear enough: this is nothing to do with the
@@ -137,9 +131,17 @@
 (defmethod emit-insts ((codegen basic-codegen) insts)
   (asetf (codegen-insts codegen) (revappend insts it)))
 
+(defmethod emit-decl ((codegen basic-codegen) inst)
+  (push inst (codegen-vars codegen)))
+
+(defmethod emit-decls ((codegen basic-codegen) insts)
+  (asetf (codegen-vars codegen) (revappend insts it)))
+
 (defmethod ensure-var ((codegen basic-codegen) name type &optional init)
   (let* ((vars (codegen-vars codegen))
-	 (var (find name vars :key #'inst-name :test #'equal)))
+	 (var (find name
+		    (remove-if-not (lambda (var) (typep var 'var-inst)) vars)
+		    :key #'inst-name :test #'equal)))
     (cond ((not var)
 	   (setf (codegen-vars codegen)
 		 (cons (make-var-inst name type init) vars)))
@@ -156,7 +158,7 @@
 
    This is the real deal.  Subclasses may which to attach additional state
    for convenience's sake, but this class is self-contained.  It supports the
-   CODEGEN-PUSH, CODEGEN-POP and CODEGEN-POP-FUNCTION protocols."))
+   `codegen-push', `codegen-pop' and `codegen-pop-function' protocols."))
 
 (defmethod codegen-push ((codegen codegen))
   (with-slots (vars insts temp-index stack) codegen
@@ -188,7 +190,7 @@
 			   (c-type-equal-p type (inst-type var)))
 		      name
 		      nil)))
-	      vars)
+	      (remove-if-not (lambda (var) (typep var 'var-inst)) vars))
 	(let* ((name (make-instance 'temporary-variable
 				    :in-use-p t
 				    :tag (prog1 temp-index