Editing Compiler-compiler (section)

==== Generators language ====
Generators Language had semantics similar to [[Lisp (programming language)|Lisp]]. The parse [[Tree (data structure)|tree]] was thought of as a recursive list. The general form of a Generator Language function is:
<pre>  function-name(first-unparse_rule) =&gt; first-production_code_generator
           (second-unparse_rule) =&gt; second-production_code_generator
           (third-unparse_rule) =&gt; third-production_code_generator
               ...</pre>
The code to process a given [[Tree (data structure)|tree]] included the features of a general purpose programming language, plus a form: &lt;stuff&gt;, which would emit (stuff) onto the output file. 
A generator call may be used in the unparse_rule. The generator is passed the element of unparse_rule pattern in which it is placed and its return values are listed in (). For example:
<pre>  expr_gen(ADD[expr_gen(x),expr_gen(y)]) =&gt;
                                &lt;AR + (x*16)+y;&gt;
                                releasereg(y);
                                return x;
               (SUB[expr_gen(x),expr_gen(y)])=&gt;
                                &lt;SR + (x*16)+y;&gt;
                                releasereg(y);
                                return x;
               (MUL[expr_gen(x),expr_gen(y)])=&gt;
                              .
                              .
                              .
               (x)=&gt;     r1 = getreg();
                            load(r1, x);
                            return r1;
...</pre>
That is, if the parse [[Tree (data structure)|tree]] looks like (ADD[<something1>,<something2>]), expr_gen(x) would be called with <something1> and return x. A variable in the unparse rule is a local variable that can be used in the production_code_generator. expr_gen(y) is called with <something2> and returns y. Here is a generator call in an unparse rule is passed the element in the position it occupies. Hopefully in the above x and y will be registers on return. The last transforms is intended to load an atomic into a register and return the register. The first production would be used to generate the 360 "AR" (Add Register) instruction with the appropriate values in general registers. The above example is only a part of a generator. Every generator expression evaluates to a value that con then be further processed. The last transform could just as well have been written as:
<pre>
               (x)=&gt;     return load(getreg(), x);
</pre>
In this case load returns its first parameter, the register returned by getreg(). the functions load and getreg are other CWIC generators.