CH A PT ER 1 6 LEXI NG A ND PARS IN G in Font

Printing PDF417 in Font CH A PT ER 1 6 LEXI NG A ND PARS IN G

[Assign ("counter",Int 100); Assign ("accum",Int 0); While (Val "counter", Seq [Assign ("counter",Minus (Val "counter",Int 1)); Assign ("accum",Plus (Val "accum",Val "counter"))]); Print Val "accum"] Writing an evaluator for Kitty is straightforward. Here we utilize an environment that maps variable names to the integer values they store. As you expect, assignments in the source language add a binding for a given variable, and evaluating variables reads a value from this environment. Because of the lack of other types in Kitty, we use a nonzero value for the Boolean true and zero for false and wire the logic of the conditional and looping construct accordingly: let rec evalE (env: Map<string, int>) = function | Val v -> if env.ContainsKey v then env.[v] else failwith ("unbound variable: " + v) | Int i -> i | Plus (e1, e2) -> evalE env e1 + evalE env e2 | Minus (e1, e2) -> evalE env e1 - evalE env e2 | Times (e1, e2) -> evalE env e1 * evalE env e2 and eval (env: Map<string, int>) = function | Assign (v, e) -> env.Add(v, evalE env e) | While (e, body) -> let rec loop env e body = if evalE env e <> 0 then loop (eval env body) e body else env loop env e body | Seq stmts -> List.fold_left eval env stmts | IfThen (e, stmt) -> if evalE env e <> 0 then eval env stmt else env | IfThenElse (e, stmt1, stmt2) -> if evalE env e <> 0 then eval env stmt1 else eval env stmt2 | Print e -> print_int (evalE env e); env With these at hand, continuing the same interactive session, you can now evaluate the sample Kitty program: > match parseText sample with | Prog stmts -> eval Map.empty (Seq stmts) |> ignore;; 4950 val it : unit = ()

If necessary, you can also compile the AST, the lexer, and the parser together into a DLL or as part of an EXE: fsc a o KittySyntax.dll kittyAst.fs kittyParser.fs kittyLexer.fs

There is one final case of parsing that is common when working with binary data. That is, say you want to work with a format that is conceptually relatively easy to parse and generate (such as a binary format) but where the process of actually writing the code to crack and encode the format is somewhat tedious. In this section, we cover a useful set of techniques to write readers and writers for binary data quickly and reliably. As the running example, we will show a set of pickling (also called marshalling) and unpickling combinators to generate and read a binary format of our own design. The combinators can easily be adapted to work with existing binary formats such as those used for network packets. Picklers and unpicklers for different data types will be function values that have signatures as follows: type outstate = System.IO.BinaryWriter type instate = System.IO.BinaryReader type pickler<'a> = 'a -> outstate -> unit type unpickler<'a> = instate -> 'a Here instate and outstate are types that will record information during the pickling or parsing process. In this section, these are just binary readers and writers, but more generally they can be any type that can collect information and help compact the data during the writing process, such as by ensuring that repeated strings are given unique identifiers during the pickling process. At the heart of every such library lies a set of primitive leaf functions for the base cases of aggregate data structures. For example, when working with binary streams, this is the usual set of primitive read/write functions: let byteP (b: byte) (st: outstate) = st.Write(b) let byteU (st: instate) = st.ReadByte() You can now begin to define additional pickler/unpickler pairs: let boolP b st = byteP (if b then 1uy else 0uy) st let boolU st = let b = byteU st in (b = 1uy) let int32P i st byteP (byte byteP (byte byteP (byte byteP (byte = (i &&& 0xFF)) st ((i >>> 8) &&& 0xFF)) st ((i >>> 16) &&& 0xFF)) st ((i >>> 24) &&& 0xFF)) st