Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Annotation of /branches/vis12/src/compiler/c-util/gen-inputs.sml
ViewVC logotype

Annotation of /branches/vis12/src/compiler/c-util/gen-inputs.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2041 - (view) (download)

1 : jhr 1820 (* gen-inputs.sml
2 :     *
3 :     * COPYRIGHT (c) 2012 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     * All rights reserved.
5 :     *)
6 :    
7 :     structure GenInputs : sig
8 :    
9 : jhr 1845 (* input variable descriptor: type, name, description, has default *)
10 : jhr 2012 type input_desc = (TreeIL.Ty.ty * string * string option * bool)
11 : jhr 1820
12 :     val gatherInputs : TreeIL.block -> input_desc list
13 :    
14 : jhr 2041 (* generate the input initialization structure that we use to initialize input
15 :     * globals from command-line arguments in stand-alone executables.
16 :     *)
17 :     val genInputsStruct : TargetUtil.target_desc * input_desc list -> CLang.decl
18 :    
19 :     (* generate a function to register command-line options for setting the input variables *)
20 : jhr 1820 val genRegisterInputs : TargetUtil.target_desc * input_desc list -> CLang.decl
21 :    
22 : jhr 2041 (* generate a function to initialize the global input variables from the command-line inputs *)
23 :     val genInitInputs : TargetUtil.target_desc * input_desc list -> CLang.decl
24 :    
25 :     (* generated the functions to initialize inputs for the library API *)
26 : jhr 1820 val genInputFuns : TargetUtil.target_desc * input_desc list -> CLang.decl list
27 :    
28 :     end = struct
29 :    
30 :     structure IL = TreeIL
31 :     structure Ty = TreeIL.Ty
32 :     structure CL = CLang
33 :     structure N = CNames
34 :     structure TrTy = CTyTranslate
35 :    
36 : jhr 2012 type input_desc = (Ty.ty * string * string option * bool)
37 : jhr 1820
38 :     val nrrdPtrTy = CL.T_Ptr(CL.T_Named "Nrrd")
39 :     val wrldPrefixTy = CL.T_Ptr(CL.T_Named "WorldPrefix_t")
40 :    
41 :     type target_desc = TargetUtil.target_desc
42 :    
43 :     (* translate a TreeIL type to the C types used to represent it in the external API *)
44 :     val trType = CTyTranslate.toCType
45 :    
46 :     (* an l-value expression for accessing a global variable *)
47 :     fun global name = CL.mkIndirect(CL.mkIndirect(CL.mkVar "wrld", "globals"), name)
48 :    
49 :     (* gather the input globals from the input initialization block *)
50 :     fun gatherInputs (IL.Block{body, ...}) = let
51 : jhr 2026 fun inputInfo (x, name, desc, NONE) = SOME(IL.Var.ty x, name, desc, false)
52 :     | inputInfo (x, name, desc, SOME _) = SOME(IL.Var.ty x, name, desc, true)
53 :     fun gather (IL.S_Input inp) = inputInfo inp
54 :     | gather (IL.S_InputNrrd inp) = inputInfo inp
55 : jhr 1820 | gather _ = NONE
56 :     in
57 :     List.mapPartial gather body
58 :     end
59 :    
60 : jhr 2041 (* generate the input initialization structure that we use to initialize input
61 :     * globals from command-line arguments in stand-alone executables.
62 :     *)
63 :     fun genInputsStruct (tgt : target_desc, inputs) = let
64 :     fun mkField (Ty.DynSeqTy _, name, _, _) = (CL.charPtr, name)
65 :     | mkField (Ty.ImageTy _, name, _, _) = (CL.charPtr, name)
66 :     | mkField (ty, name, _, _) = (trType ty, name)
67 :     in
68 :     CL.D_StructDef(NONE, List.map mkField inputs, SOME(N.inputsTy tgt))
69 :     end
70 :    
71 : jhr 1845 (* generate code to register command-line options for setting the input variables *)
72 : jhr 1820 fun genRegisterInputs (tgt, inputs) = let
73 : jhr 2041 (* the inputs pointer type *)
74 :     val inputPtrTy = CL.T_Ptr(CL.T_Named(N.inputsTy tgt))
75 :     (* some common variables *)
76 :     val inpV = CL.mkVar "inp"
77 :     val optsV = CL.mkVar "opts"
78 :     (* register a given input *)
79 :     fun registerInput (ty, name, desc, hasDflt) = CL.mkCall(N.input ty, [
80 :     optsV, CL.mkStr name, CL.mkStr(Option.getOpt(desc, "")),
81 :     CL.mkUnOp(CL.%&, CL.mkIndirect(inpV, name)),
82 :     CL.mkBool hasDflt
83 :     ])
84 :     in
85 :     CL.D_Func(
86 :     ["static"], CL.voidTy, N.registerOpts,
87 :     [CL.PARAM([], inputPtrTy, "inp"), CL.PARAM([], CL.T_Ptr(CL.T_Named N.optionsTy), "opts")],
88 :     CL.mkBlock(List.map registerInput inputs))
89 :     end
90 :    
91 :     (* generate code to initialize the global input variables from the command-line inputs *)
92 :     fun genInitInputs (tgt, inputs) = let
93 : jhr 1820 (* the world pointer type *)
94 :     val worldPtrTy = CL.T_Ptr(CL.T_Named(N.worldTy tgt))
95 : jhr 1845 (* the global state pointer type *)
96 :     val globPtrTy = CL.T_Ptr(CL.T_Named(N.globalTy tgt))
97 : jhr 2041 (* the inputs pointer type *)
98 :     val inputPtrTy = CL.T_Ptr(CL.T_Named(N.inputsTy tgt))
99 : jhr 1845 (* some common variables *)
100 : jhr 2041 val inpV = CL.mkVar "inp"
101 : jhr 1845 val globV = CL.mkVar "glob"
102 :     val optsV = CL.mkVar "opts"
103 : jhr 2041 (* initialize a given input global; for sequences and images, this requires
104 :     * loading the value from the specified nrrd file, while for other types
105 :     * we just copy the values.
106 :     *)
107 :     fun initInput (Ty.DynSeqTy elemTy, name, desc, hasDflt) = CL.mkCall("dummy", [
108 : jhr 2012 optsV, CL.mkStr name, CL.mkStr(Option.getOpt(desc, "")),
109 : jhr 1845 CL.mkUnOp(CL.%&, CL.mkIndirect(globV, name)),
110 :     CL.mkBool hasDflt
111 :     ])
112 : jhr 2041 | initInput (Ty.ImageTy info, name, desc, hasDflt) = CL.mkCall("dummy", [
113 : jhr 2033 optsV, CL.mkStr name, CL.mkStr(Option.getOpt(desc, "")),
114 :     CL.mkUnOp(CL.%&, CL.mkIndirect(globV, name)),
115 :     CL.mkBool hasDflt
116 :     ])
117 : jhr 2041 | initInput (ty, name, _, _) =
118 :     CL.mkAssign(CL.mkIndirect(globV, name), CL.mkIndirect(inpV, name))
119 : jhr 1820 in
120 :     CL.D_Func(
121 : jhr 2041 ["static"], CL.voidTy, N.initInputs,
122 :     [CL.PARAM([], worldPtrTy, "wrld"), CL.PARAM([], inputPtrTy, "inp")],
123 : jhr 1845 CL.mkBlock(
124 :     CL.mkDeclInit(globPtrTy, "glob", CL.mkIndirect(CL.mkVar "wrld", "globals")) ::
125 : jhr 2041 List.map initInput inputs))
126 : jhr 1820 end
127 :    
128 : jhr 2041 (* for each input variable we generate two or three top-level declarations in the
129 :     * exported API.
130 :     *)
131 : jhr 1820 fun genInputFuns (tgt, inputs) = let
132 :     (* the world pointer type *)
133 :     val worldPtrTy = CL.T_Ptr(CL.T_Named(N.worldTy tgt))
134 :     val wrldParam = CL.PARAM([], worldPtrTy, "wrld")
135 :     (* create decls for an input variable *)
136 :     fun mkInputDecls (ty, name, desc, hasDflt) = let
137 :     (* create a description declaration for the input variable *)
138 : jhr 2012 val descDcl = (case desc
139 :     of SOME desc => [
140 :     CL.D_Var([], CL.T_Ptr(CL.T_Named "const char"),
141 :     N.inputDesc(tgt, name),
142 :     SOME(CL.I_Exp(CL.mkStr desc)))
143 :     ]
144 :     | NONE => []
145 :     (* end case *))
146 : jhr 1820 val getDcl = if hasDflt
147 :     then let
148 :     val getName = N.inputGet(tgt, name)
149 :     (* convert the input type to a by-reference C type *)
150 :     val outTy = (case ty
151 :     of Ty.BoolTy => CL.T_Ptr(trType ty)
152 :     | Ty.StringTy => CL.T_Ptr(trType ty)
153 :     | Ty.IntTy => CL.T_Ptr(trType ty)
154 :     | Ty.TensorTy[] => CL.T_Ptr(trType ty)
155 :     | Ty.TensorTy _ => trType ty
156 :     | Ty.SeqTy _ => trType ty
157 :     | Ty.DynSeqTy _ => CL.T_Ptr(trType ty)
158 :     | Ty.ImageTy _ => CL.T_Ptr CL.charPtr
159 :     | _ => raise Fail(concat["bogus input type ", Ty.toString ty])
160 :     (* end case *))
161 :     in [
162 :     CL.D_Func([], CL.voidTy, getName, [wrldParam, CL.PARAM([], outTy, "v")],
163 :     CL.mkBlock(
164 :     TrTy.copyToC{ty=ty, dst=CL.mkUnOp(CL.%*, CL.mkVar "v"), src=global name}))
165 :     ] end
166 :     else []
167 :     val setDcl = (case ty
168 :     of Ty.ImageTy info => let
169 :     val dim = ImageInfo.dim info
170 :     in [
171 :     CL.D_Func(
172 :     [], CL.boolTy, N.inputSetByName(tgt, name),
173 :     [wrldParam, CL.PARAM(["const"], CL.charPtr, "s")],
174 :     CL.mkBlock[
175 :     (* FIXME: we should also generate code to check that the loaded image has the right type, etc. *)
176 :     CL.mkReturn(SOME(
177 :     CL.mkBinOp(CL.mkVar "DIDEROT_FAIL", CL.#==,
178 :     CL.mkApply(N.loadImage dim, [
179 :     CL.mkCast(wrldPrefixTy, CL.mkVar "wrld"),
180 :     CL.mkVar "s", CL.mkUnOp(CL.%&, global name)
181 :     ]))))
182 :     ]),
183 :     CL.D_Func(
184 :     [], CL.boolTy, N.inputSet(tgt, name),
185 :     [wrldParam, CL.PARAM([], nrrdPtrTy, "nin")],
186 :     CL.mkBlock[
187 :     (* FIXME: we should also generate code to check that the loaded image has the right type, etc. *)
188 :     CL.mkReturn(SOME(
189 :     CL.mkBinOp(CL.mkVar "DIDEROT_FAIL", CL.#==,
190 :     CL.mkApply(N.setImage dim, [
191 :     CL.mkCast(wrldPrefixTy, CL.mkVar "wrld"),
192 :     CL.mkVar "nin", CL.mkUnOp(CL.%&, global name)
193 :     ]))))
194 :     ])
195 :     ] end
196 : jhr 1999 (* dynamic sequence loader prototype:
197 :     Diderot_DynSeq_t *Diderot_DynSeqLoadTY (
198 :     WorldPrefix_t *wrld,
199 :     Nrrd *nin,
200 :     unsigned int nDims,
201 :     unsigned int *dims);
202 :     *)
203 :     (*
204 :     | Ty.DynSeqTy elemTy => [
205 :     CL.D_Func(
206 :     [], CL.boolTy, N.inputSetByName(tgt, name),
207 :     [wrldParam, CL.PARAM(["const"], CL.charPtr, "s")],
208 :     CL.mkBlock[
209 :     CL.mkReturn(SOME(
210 :     CL.mkBinOp(CL.mkVar "DIDEROT_FAIL", CL.#==,
211 :     CL.mkApply(N.loadSeq elemTy, [
212 :     CL.mkCast(wrldPrefixTy, CL.mkVar "wrld"),
213 :     CL.mkVar "s", CL.mkUnOp(CL.%&, global name)
214 :     ]))))
215 :     ]),
216 :     CL.D_Func(
217 :     [], CL.boolTy, N.inputSet(tgt, name),
218 :     [wrldParam, CL.PARAM([], nrrdPtrTy, "nin")],
219 :     CL.mkBlock[
220 :     CL.mkReturn(SOME(
221 :     CL.mkBinOp(CL.mkVar "DIDEROT_FAIL", CL.#==,
222 :     CL.mkApply(N.loadSeq elemTy, [
223 :     CL.mkCast(wrldPrefixTy, CL.mkVar "wrld"),
224 :     CL.mkVar "nin", CL.mkUnOp(CL.%&, global name)
225 :     ]))))
226 :     ])
227 :     ]
228 :     *)
229 :     | Ty.DynSeqTy elemTy => raise Fail "dynamic input not supported yet"
230 : jhr 1820 | _ => [
231 :     CL.D_Func(
232 :     [], CL.boolTy, N.inputSet(tgt, name),
233 :     [wrldParam, CL.PARAM([], trType ty, "v")],
234 :     CL.mkBlock(
235 :     TrTy.copyFromC{ty=ty, dst=global name, src=CL.mkVar "v"} @
236 :     [CL.mkReturn(SOME(CL.mkVar "false"))]))
237 :     ]
238 :     (* end case *))
239 :     in
240 :     descDcl @ getDcl @ setDcl
241 :     end
242 :     in
243 :     List.foldr (fn (input, dcls) => mkInputDecls input @ dcls) [] inputs
244 :     end
245 :    
246 :     end

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0