Previous: Functions in pytranslate [Contents][Index]
Working of pytranslate:
$pytranslate
defined in share/pytranslate/pytranslate.lisp.
$pytranslate
calls the function maxima-to-ir
with the Maxima expression as an argument(henceforth referred as expr
).
maxima-to-ir
determines if expr
is atomic or non-atomic(lisp cons form). If atomic, atom-to-ir
is called with expr
which returns the IR for the atomic expression.atom-to-ir
in accordance with the IR.
expr
is non-atomic, the function cons-to-ir
is called with expr
as an argument.cons-to-ir
looks for (caar expr)
which specifies the type of expr
, in hash-table *maxima-direct-ir-map* and if the type is found, then appends the retrieved IR with the result of lisp call (mapcar #'maxima-to-ir (cdr expr))
, which applies maxima-to-ir function to all the elements present in the list. Effectively, recursively generate IR for all the elements present in expr
and append them to the IR map for the type.(%i9) show_form(a+b); ((MPLUS) $B $A)
(%i10) pytranslate(a+b, t); (body (op + (element-array (symbol "v") (string "b")) \ (element-array (symbol "v") (string "a")))) (%o10) (v["b"] + v["a"])
Here, operator + with internal maxima representation, (mplus)
is present in *maxima-direct-ir-map* and mapped to (op +)
to which the result of generating IR for all other elements of the list (a b), i.e. (ELEMENT-ARRAY (SYMBOL "v") (STRING "b")) (ELEMENT-ARRAY (SYMBOL "v") (STRING "a"))
is appended.
(caar expr)
is not found in *maxima-direct-ir-map*, then cons-to-ir
looks for the type in *maxima-special-ir-map* which returns the function to handle the translation of the type of expr
. cons-to-ir
then calls the returned function with argument expr
as an argument.(%i11) show_form(g(x) := x^2); ((mdefine simp) (($g) $x) ((mexpt) $x 2))
(%i12) pytranslate(g(x):=x^2, t); (body (body (func-def (symbol "g") ((symbol "x") (op-no-bracket = (symbol "v") (symbol "v"))) (body-indented (op-no-bracket = (symbol "v") (funcall (symbol "stack") \ (dictionary) (symbol "v"))) (obj-funcall (symbol "v") (symbol "ins") (dictionary \ ((string "x") (symbol "x")))) (funcall (symbol "return") (funcall (element-array (symbol "f") (string "pow")) (element-array (symbol "v") (string "x")) (num 2 0))))) (op-no-bracket = (element-array (symbol "f") (string "g")) \ (symbol "g")))) (%o12) def g(x, v = v): v = Stack({}, v) v.ins({"x" : x}) return(f["pow"](v["x"], 2)) f["g"] = g
Here, mdefine
, which is the type of expr
is present in *maxima-special-ir-map* which returns func-def-to-ir
as handler function, which is then called with expr
to generate the IR.
To define/modify translation for a type, add an entry to *maxima-direct-ir-map* if only a part of the IR needs to be generated and the rest can be appended, otherwise, for complete handling of expr
, add an entry to *maxima-special-ir-map* and define a function with the name defined in *maxima-special-ir-map* which returns the IR for the form. The function naming convention for ir generators is (type)-to-ir, where type is the (caar expr)
for expression(mdefine -> func-def-to-ir
). The function must return a valid IR for the specific type.
ir-to-python
is called with the generated ir
as an argument, which performs the codegen in a recursive manner.
ir-to-python
looks for lisp (car ir)
in the hash-table *ir-python-direct-templates*, which maps IR type to function handlers and calls the function returned with ir
as an argument.
Previous: Functions in pytranslate [Contents][Index]