Re: [Caml-list] More Caml

[Jon Harrop <jon@ffconsultancy.com>]

On Tuesday 23 December 2008 10:04:55 Richard Jones wrote:
> On Tue, Dec 23, 2008 at 06:07:37AM +0000, Jon Harrop wrote:
> > another interesting project and a JIT compiler for OCaml's existing
> > bytecode would also be nice.
>
> Probably easier to start with the abstract syntax tree that camlp4
> writes out.  http://brion.inria.fr/gallium/index.php/AST

Actually I was previously compiling quoted OCaml code via Camlp4. However, 
lack of support for camlp4 macros in Tuareg and lack of documentation about 
Camlp4 itself (how do you get a tuple "out"!?) made this sufficiently painful 
that I ditched it and opted for writing out the AST in variant types by hand 
instead, e.g. my mandelbrot benchmark:

let mandelbrot n =
  [Defn.Function("lerp", ["i", Type.Int; "n", Type.Int], [Type.Float],
		 Float 2.0 *:. FloatOfInt(Var "i") /:. FloatOfInt(Var "n") -:.
		   Float 1.0);
   
   Defn.Function("zsqr",
		 ["r", Type.Float; "i", Type.Float], [Type.Float; Type.Float],
		 Values[Var "r" *:. Var "r" -:. Var "i" *:. Var "i";
			Float 2.0 *:. Var "r" *:. Var "i"]);

   Defn.Function("znorm2", ["r", Type.Float; "i", Type.Float], [Type.Float],
		 Var "r" *:. Var "r" +:. Var "i" *:. Var "i");

   Defn.Function
     ("pixel2", ["n", Type.Int;
		 "zr", Type.Float;
		 "zi", Type.Float;
		 "cr", Type.Float;
		 "ci", Type.Float], [Type.String],
      If(Var "n" =: Int 65536, String " ",
	 If(apply(Var "znorm2", [Var "zr"; Var "zi"], Type.Float) >=:.
	      Float 4.0,
	    String ".",
	    Call(["zr", Type.Float; "zi", Type.Float],
		 Var "zsqr", [Var "zr"; Var "zi"],
		 apply(Var "pixel2", [Var "n" +: Int 1;
				      Var "zr" +:. Var "cr";
				      Var "zi" +:. Var "ci";
				      Var "cr"; Var "ci"], Type.Unit)))));

   Defn.Function
     ("pixel", ["n", Type.Int;
		"zr", Type.Float;
		"zi", Type.Float;
		"cr", Type.Float;
		"ci", Type.Float], [Type.String],
      If(Var "n" =: Int 65536, String " ",
	 If(Var "zr" *:. Var "zr" +:. Var "zi" *:. Var "zi" >=:. Float 4.0,
	    String ".",
	    apply(Var "pixel",
		  [Var "n" +: Int 1;
		   Var "zr" *:. Var "zr" -:.
		     Var "zi" *:. Var "zi" +:. Var "cr";
		   Float 2.0 *:. Var "zr" *:. Var "zi" +:. Var "ci";
		   Var "cr"; Var "ci"], Type.Unit))));
   
   Defn.Function
     ("row", ["i", Type.Int; "j", Type.Int; "n", Type.Int], [],
      If(Var "i" >: Var "n", Unit,
	 Compound
	   [ Printf[apply(Var "pixel",
			  [Int 0;
			   Float 0.0; Float 0.0;
			   apply(Var "lerp", [Var "i"; Var "n"], Type.Float);
			   apply(Var "lerp", [Var "j"; Var "n"], Type.Float)],
			  Type.Unit)];
	     apply(Var "row",
		   [Var "i" +: Int 1; Var "j"; Var "n"], Type.Unit)]));

   Defn.Function
     ("col", ["j", Type.Int; "n", Type.Int], [],
      If(Var "j" >: Var "n", Unit,
	 Compound
	   [ apply(Var "row", [Int 0; Var "j"; Var "n"], Type.Unit);
	     Printf[String "\n"];
	     apply(Var "col", [Var "j" +: Int 1; Var "n"], Type.Unit)]));

   Defn.Function
     ("main", [], [], apply(Var "col", [Int 0; Int n], Type.Unit))]

I'll probably just write a "real" parser and implement a REPL for it instead, 
probably after I've got algebraic datatypes and generic printing working. 
Hmm, maybe I should use ocamllex and ocamlyacc instead of Camlp4 because I'd 
like a better lexer as well (e.g. complex literals). I had been thinking 
about using parser combinators to make bootstrapping easier but they're a 
world of pain and I don't actually see any point in bootstrapping anyway.

Are there any usable OCaml frameworks that can parse and pretty print (i.e. 
remove superfluous parentheses by taking associativity, precedence and fixity 
into account) from the same grammar definition?

-- 
Dr Jon Harrop, Flying Frog Consultancy Ltd.
http://www.ffconsultancy.com/?e