X-Git-Url: https://code.consxy.com/gitweb/gitweb.cgi?a=blobdiff_plain;f=src%2Fmain%2Ftranspile.lisp;h=956b226eaea577f61fb3de51b4ac0417e8761a4d;hb=807df6b6f160d82cc04ca02ce88d61ee58439ad1;hp=9dc373f6b74cbc29750fb6b1fc034e23604ec4e0;hpb=9413d3737ae1c07d7ec2cad29ef3a6d50ab859a9;p=clnl diff --git a/src/main/transpile.lisp b/src/main/transpile.lisp index 9dc373f..956b226 100644 --- a/src/main/transpile.lisp +++ b/src/main/transpile.lisp @@ -1,40 +1,103 @@ (in-package #:clnl-transpiler) (defparameter *prims* nil) -(defparameter *prim-aliases* nil) (defvar *local-variables* nil) +(defvar *dynamic-prims* nil) (defun prim-name (prim) (getf prim :name)) (defun prim-type (prim) (getf prim :type)) (defun prim-func (prim) (getf prim :func)) -(defun is-reporter (prim) (eql :reporter (getf prim :type))) -(defun is-command (prim) (eql :command (getf prim :type))) +(defun prim-reporter-p (prim) (eql :reporter (getf prim :type))) +(defun prim-command-p (prim) (eql :command (getf prim :type))) (defun find-prim (symb) (when symb - (or - (find symb *prims* :key #'prim-name) - (find-prim (getf (find symb *prim-aliases* :key #'prim-name) :real-symb))))) + (find-if + (lambda (prim-name) (or (eql symb prim-name) (and (listp prim-name) (find symb prim-name)))) + (append *prims* *dynamic-prims*) + :key #'prim-name))) -; Let this grow, slowly but surely, eventually taking on calling context, etc. -; For now, it's just a -(defun transpile-commands (parsed-ast) - "TRANSPILE-COMMANDS PARSED-AST => AST +(defun transpile (parsed-ast &optional dynamic-prims) + "TRANSPILE PARSED-AST &optional DYNAMIC-PRIMS => AST + + DYNAMIC-PRIMS: DYNAMIC-PRIM* + DYNAMIC-PRIM: (:name NAME :type TYPE :macro MACRO :func FUNC) + TYPE: :reporter | :command ARGUMENTS AND VALUES: PARSED-AST: An ast as returned by the parser AST: An common lisp AST that can be actually run in a common lisp instance + NAME: A symbol in the keyword package + MACRO: A macro that will be called with the arguments ast + FUNC: A function that will be called with the transpiled arguments DESCRIPTION: - TRANSPILE-COMMANDS takes a unambigious PARSED-AST and converts it to - Common Lisp code. + TRANSPILE takes a unambigious PARSED-AST and converts it to + Common Lisp code. The PARSED-AST must be either a list of commands, + or a single reporter. + + When a set of DYNAMIC-PRIMS is included, external language constructs + can be also transpiled. The provided functions will be inserted into + the returned AST with a call to FUNCALL. If :macro is included, instead + of having a call to FUNCALL provided, the macro will be run at netlogo + transpile time, with the arguments it should have specified to the + parser. The result of that function call will then be dropped into + the ast. Calling eval on that code should work correctly as long as you have a - running engine. This is the entry point for commands, so it does - extra checking to ensure that commands are actually in the PARSED-AST." + running engine." + + (let + ((*dynamic-prims* + (mapcar + (lambda (prim) + (if (getf prim :macro) + (append (list :func (getf prim :macro)) prim) + (append (list :func (lambda (&rest args) `(funcall ,(getf prim :func) ,@args))) prim))) + dynamic-prims))) + (cond + ((command-list-p parsed-ast) (transpile-commands parsed-ast)) + ((and (listp parsed-ast) (= 1 (length parsed-ast)) (reporter-p (car parsed-ast))) + (transpile-reporter (car parsed-ast))) + (t (error "Is neither a list of commands nor a reporter: ~S" parsed-ast))))) + +(defun command-list-p (parsed-ast) + "COMMAND-LIST-P PARSED-AST => RESULT + +ARGUMENTS AND VALUES: + + PARSED-AST: An ast as returned by the parser + RESULT: A boolean + +DESCRIPTION: + + COMMAND-LIST-P returns whether the parsed-ast is a valid list + of commands." + (and + (every #'listp parsed-ast) + (every #'prim-command-p (mapcar #'find-prim (mapcar #'car parsed-ast))))) + +(defun reporter-p (parsed-ast) + "REPORTER-P PARSED-AST => RESULT + +ARGUMENTS AND VALUES: + + PARSED-AST: An ast as returned by the parser + RESULT: A boolean + +DESCRIPTION: + + REPORTER-P returns whether the parsed-ast is a valid reporter." + (and + (symbolp (car parsed-ast)) + (prim-reporter-p (find-prim (car parsed-ast))))) + +; Let this grow, slowly but surely, eventually taking on calling context, etc. +; For now, it's just a +(defun transpile-commands (parsed-ast) `(progn ,@(transpile-commands-inner parsed-ast))) @@ -67,42 +130,33 @@ DESCRIPTION: (cond ((not (listp command)) (error "Expected a statement of some sort")) ((not (find-prim (car command))) (error "Couldn't find the command for ~S" (car command))) - ((not (is-command (find-prim (car command)))) (error "Expected command, got ~S" (car command))) + ((not (prim-command-p (find-prim (car command)))) (error "Expected command, got ~S" (car command))) (t (apply (prim-func (find-prim (car command))) (mapcar #'transpile-reporter (cdr command)))))) (defun transpile-reporter (reporter) - "TRANSPILE-REPORTER REPORTER => AST - -ARGUMENTS AND VALUES: - - REPORTER: An ast returned from the parser. - AST: An common lisp AST that can be actually run in a common lisp instance - -DESCRIPTION: - - TRANSPILE-REPORTER takes a unambigious PARSED-AST and converts it to - Common Lisp code. - - Calling eval on that code should work correctly as long as you have a - running engine. This is the entry point for reporters, so it does - extra checking to ensure that the reporter is actually in the REPORTER. - - The Common lisp code that is returned, when run, will return some value." (cond ((numberp reporter) reporter) ; The parser converts to double for us + ((stringp reporter) reporter) ; The parser should have checked that having a symbol here is ok ((symbolp reporter) (intern (symbol-name reporter) clnl:*model-package*)) ((not (listp reporter)) (error "Expected a statement of some sort")) ((eql :command-block (car reporter)) (transpile-command-block reporter)) + ((eql :list-literal (car reporter)) (cons 'list (mapcar #'transpile-reporter (cdr reporter)))) + ((eql :reporter-block (car reporter)) (transpile-reporter-block reporter)) ((and (symbolp (car reporter)) (find (car reporter) *local-variables*)) (intern (symbol-name (car reporter)) clnl:*model-package*)) ((not (find-prim (car reporter))) (error "Couldn't find the reporter for ~S" (car reporter))) - ((not (is-reporter (find-prim (car reporter)))) (error "Expected reporter, got ~S" (car reporter))) + ((not (prim-reporter-p (find-prim (car reporter)))) (error "Expected reporter, got ~S" (car reporter))) (t (apply (prim-func (find-prim (car reporter))) (mapcar #'transpile-reporter (cdr reporter)))))) (defun transpile-command-block (block) `(lambda () ,@(transpile-commands-inner (cdr block)))) +(defun transpile-reporter-block (block) + (when (/= (length block) 2) (error "Reporter block invalid ~S" block)) + `(lambda () + ,(transpile-reporter (cadr block)))) + ; Undoes the previous function :) (defun make-command-block-inline (block) (cddr block)) @@ -116,8 +170,8 @@ DESCRIPTION: (defmacro defkeywordprim (name) `(defprim ,name :reporter (lambda () ',name))) -(defmacro defprim-alias (name real-symb) - `(push (list :name ,name :real-symb ,real-symb) *prim-aliases*)) +(defmacro defagentvalueprim (name) + `(defprim ,name :reporter (lambda () `(clnl-nvm:agent-value ,,name)))) ; We count on the parser to handle arguemnts for us, when collating things. @@ -129,27 +183,55 @@ DESCRIPTION: (defsimpleprim :+ :reporter cl:+) (defsimpleprim :* :reporter cl:*) (defsimpleprim :/ :reporter cl:/) -(defprim :any? :reporter (lambda (agentset) `(> (length ,agentset) 0))) +(defprim :any? :reporter (lambda (agentset) `(> (clnl-nvm:count ,agentset) 0))) (defsimpleprim :ask :command clnl-nvm:ask) -(defsimpleprim :crt :command clnl-nvm:create-turtles) +(defagentvalueprim :color) +(defsimpleprim '(:clear-all :ca) :command clnl-nvm:clear-all) +(defsimpleprim :count :reporter clnl-nvm:count) +(defprim '(:crt :create-turtles) :command (lambda (num &optional fn) `(clnl-nvm:create-turtles ,num nil ,fn))) (defsimpleprim :die :command clnl-nvm:die) +(defsimpleprim :display :command clnl-nvm:display) (defsimpleprim :fd :command clnl-nvm:forward) +(defsimpleprim :hatch :command clnl-nvm:hatch) (defprim :if :command (lambda (pred a) `(when ,pred ,@(make-command-block-inline a)))) -(defprim :ifelse :command (lambda (pred a b) - `(if ,pred - ,@(make-command-block-inline a) - ,@(make-command-block-inline b)))) - -(defprim-alias :if-else :ifelse) +(defprim '(:ifelse :if-else) + :command (lambda (pred a b) + (let + ((then (make-command-block-inline a)) + (else (make-command-block-inline b))) + `(if ,pred + ,@(if (= (length then) 1) then `((progn ,@then))) + ,@(if (= (length else) 1) else `((progn ,@else))))))) + +(defagentvalueprim :label) +(defagentvalueprim :label-color) +(defsimpleprim :let :command nil) (defsimpleprim :lt :command clnl-nvm:turn-left) +(defsimpleprim :not :reporter cl:not) (defkeywordprim :nobody) +(defsimpleprim :one-of :reporter clnl-nvm:one-of) +(defsimpleprim :of :reporter clnl-nvm:of) +(defsimpleprim :patches :reporter clnl-nvm:patches) +(defagentvalueprim :pcolor) (defsimpleprim :reset-ticks :command clnl-nvm:reset-ticks) +(defsimpleprim :random :reporter clnl-nvm:random) (defsimpleprim :random-float :reporter clnl-nvm:random-float) +(defsimpleprim :random-xcor :reporter clnl-nvm:random-xcor) +(defsimpleprim :random-ycor :reporter clnl-nvm:random-ycor) +(defprim :round :reporter (lambda (n) `(ffloor (+ ,n 0.5d0)))) (defsimpleprim :rt :command clnl-nvm:turn-right) +(defsimpleprim :set :command cl:setf) +(defsimpleprim :set-default-shape :command clnl-nvm:set-default-shape) +(defsimpleprim :setxy :command clnl-nvm:setxy) (defsimpleprim :show :command clnl-nvm:show) +(defsimpleprim :stop :command clnl-nvm:stop) +(defagentvalueprim :size) (defsimpleprim :tick :command clnl-nvm:tick) (defsimpleprim :ticks :reporter clnl-nvm:ticks) (defsimpleprim :turtles :reporter clnl-nvm:turtles) +(defsimpleprim :turtles-here :reporter clnl-nvm:turtles-here) +(defagentvalueprim :who) +(defsimpleprim :with :reporter clnl-nvm:with) ; Colors (defmacro defcolorprim (color) `(defprim ,color :reporter (lambda () `(clnl-nvm:lookup-color ,,color))))