A CIL Tutorial - Department of Computer Science - ETH Zürich

CHAPTER 14. IMPLEMENTING A SIMPLE DSL 119
let has arg of argument (a : argument) : exp =
if a.argOption then one else zero
let int code of argument (a : argument) : exp =
a.argShort.[0] | > int of char | > integer
The function initialize options takes a function for generating an lval, (e.g. field of option),
an index, a eld name, and an argument. Using the argument it generates instructions for initializing
the elds.
let initialize options (foo : int → string → lval)
(i : int) (a : argument)
: instr list
=
[Set(foo i "name", mkString a.argName, locUnknown);
Set(foo i "has arg", has arg of argument a, locUnknown);
Set(foo i "val", int code of argument a, locUnknown)]
The function create long options generates code that allocates an option array, and lls it in.
It returns the varinfo for the array, the call to malloc, and the assignments for the initializations.
let create long options (f : file) (main : fundec) (al : argument list)
: varinfo × instr × instr list
=
let malloc = findOrCreateFunc f "malloc" (mallocType f) in
let ot = findType f.globals "option" in
let o = makeTempVar main (TPtr(ot, [ ])) in
let foo = field of option o ot in
let size = integer((L.length al + 1) × ((bitsSizeOf ot)/8)) in
let mcall = Call(Some(var o), v2e malloc, [size], locUnknown) in
let inits = al | > A.of list
|> A.mapi (initialize options foo)
|> A.to list
|> L.concat
in
o, mcall, inits
With an array of options allocated and initialized, we can now generate the code for the loop that
calls getopt long. Since generating this code using type-constructors would be tedious and dicult
to read, we'll use CIL's interpreted constructors instead. To do this, we need to build a string to
pass to Formatcil.cStmts.
Before doing that, though, we'll dene a few utility functions for obtaining expressions that will
be parameters to the interpreted constructor. The function create short options generates an
expression for the string to be used as the parameter to getopt long that denes the short versions
of the arguments.