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

SCM Repository

[diderot] Annotation of /branches/vis15/src/compiler/cxx-util/print-as-cxx.sml
ViewVC logotype

Annotation of /branches/vis15/src/compiler/cxx-util/print-as-cxx.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 5108 - (view) (download)

1 : jhr 3871 (* print-as-cxx.sml
2 :     *
3 :     * Print CLang syntax trees using C++ syntax.
4 :     *
5 :     * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
6 :     *
7 :     * COPYRIGHT (c) 2016 The University of Chicago
8 :     * All rights reserved.
9 :     *)
10 :    
11 :     structure PrintAsCxx : sig
12 :    
13 : jhr 3994 val rawTyName : RawTypes.t -> string
14 :    
15 : jhr 3905 val output : TextIOPP.stream * CLang.decl -> unit
16 : jhr 3871
17 :     end = struct
18 :    
19 :     structure CL = CLang
20 :     structure PP = TextIOPP
21 :    
22 :     val indent0 = (PP.Abs 0)
23 :     val indent = (PP.Abs 4) (* standard indentation amount *)
24 :    
25 : jhr 3994 fun rawTyName rty = (case rty
26 : jhr 4317 of RawTypes.RT_Int8 => "int8_t"
27 :     | RawTypes.RT_UInt8 => "uint8_t"
28 :     | RawTypes.RT_Int16 => "int16_t"
29 :     | RawTypes.RT_UInt16 => "uint16_t"
30 :     | RawTypes.RT_Int32 => "int32_t"
31 :     | RawTypes.RT_UInt32 => "uint32_t"
32 :     | RawTypes.RT_Int64 => "int64_t"
33 :     | RawTypes.RT_UInt64 => "uint64_t"
34 :     | RawTypes.RT_Float => "float"
35 :     | RawTypes.RT_Double => "double"
36 :     (* end case *))
37 : jhr 3994
38 : jhr 3999 fun output (_, CL.D_Verbatim[]) = ()
39 :     | output (strm, decl) = let
40 : jhr 3871 val str = PP.string strm
41 :     fun sp () = PP.space strm 1
42 :     fun inHBox f = (PP.openHBox strm; f(); PP.closeBox strm)
43 :     fun ppCom s = inHBox (fn () => (str "// "; str s))
44 :     fun ppComLn s = (ppCom s; PP.newline strm)
45 :     fun ppList {pp, sep, l} = let
46 :     fun ppList' [] = ()
47 :     | ppList' [x] = pp x
48 :     | ppList' (x::xs) = (pp x; sep(); ppList' xs)
49 :     in
50 :     ppList' l
51 :     end
52 : jhr 4317 fun ppCommaList {pp, l} = ppList {pp = pp, sep = fn () => (str ","; sp()), l = l}
53 :     fun ppQName (scopes, name) = let
54 :     fun ppQ [] = str name
55 :     | ppQ (CL.SC_Namespace ns :: scopes) = (str ns; str "::"; ppQ scopes)
56 :     | ppQ (CL.SC_Type ty :: scopes) = (ppTy (ty, NONE); str "::"; ppQ scopes)
57 :     in
58 :     inHBox (fn () => ppQ scopes)
59 :     end
60 : jhr 4028 and ppTy (ty, optVar) = let
61 : jhr 3994 fun getBaseTy (CL.T_Num rty) = rawTyName rty
62 : jhr 4317 | getBaseTy (CL.T_Const(CL.T_Num rty)) = "const " ^ rawTyName rty
63 :     | getBaseTy (CL.T_Const(CL.T_Named ty)) = "const " ^ ty
64 :     | getBaseTy (CL.T_Const ty) = getBaseTy ty
65 :     | getBaseTy (CL.T_Ptr ty) = getBaseTy ty
66 :     | getBaseTy (CL.T_RestrictPtr ty) = getBaseTy ty
67 : jhr 3871 | getBaseTy (CL.T_Array(ty, _)) = getBaseTy ty
68 :     | getBaseTy (CL.T_Named ty) = ty
69 :     (* FIXME: this isn't right *)
70 : jhr 4317 | getBaseTy (CL.T_Template(name, tys)) = concat[
71 :     name, "< ", String.concatWith ", " (List.map getBaseTy tys), " >"
72 :     ]
73 : jhr 4029 | getBaseTy (CL.T_Qual(attr, ty)) = concat[attr, " ", getBaseTy ty]
74 : jhr 4317 | getBaseTy (CL.T_Member(CL.T_Named ty, ty')) = concat[ty, "::", ty']
75 :     | getBaseTy (CL.T_Member(ty as CL.T_Template _, ty')) =
76 :     concat[getBaseTy ty, "::", ty']
77 :     | getBaseTy (CL.T_Member _) = raise Fail "ill-formed type member in C++"
78 :     fun ppVar (isFirst, SOME x) = (
79 : jhr 3871 if isFirst then sp() else ();
80 : jhr 4028 ppQName x)
81 : jhr 4317 | ppVar _ = ()
82 : jhr 3955 fun pp (isFirst, CL.T_Const(CL.T_Num _), optVar) = ppVar (isFirst, optVar)
83 : jhr 4317 | pp (isFirst, CL.T_Const(CL.T_Named _), optVar) = ppVar (isFirst, optVar)
84 :     | pp (isFirst, CL.T_Const(CL.T_Template _), optVar) = ppVar (isFirst, optVar)
85 :     | pp (isFirst, CL.T_Const(CL.T_Member _), optVar) = ppVar (isFirst, optVar)
86 :     | pp (isFirst, CL.T_Const ty, optVar) = raise Fail "FIXME"
87 : jhr 3955 | pp (isFirst, CL.T_Ptr ty, optVar) = (
88 :     if isFirst then sp() else ();
89 : jhr 3871 case ty
90 :     of CL.T_Array _ => (
91 :     str "(*"; pp(false, ty, optVar); str ")")
92 :     | _ => (str "*"; pp(false, ty, optVar))
93 :     (* end case *))
94 : jhr 4317 | pp (isFirst, CL.T_RestrictPtr ty, optVar) = (
95 : jhr 3871 if isFirst then sp() else ();
96 :     case ty
97 :     of CL.T_Array _ => (
98 :     str "(*"; sp(); str "__restrict__"; sp(); pp(false, ty, optVar); str ")")
99 :     | _ => (str "*"; sp(); str "__restrict__"; sp(); pp(false, ty, optVar))
100 :     (* end case *))
101 :     | pp (isFirst, CL.T_Array(ty, optN), optVar) = (
102 :     pp (isFirst, ty, optVar);
103 :     case optN
104 :     of NONE => str "[]"
105 :     | SOME n => (str "["; str(Int.toString n); str "]")
106 :     (* end case *))
107 :     | pp (isFirst, CL.T_Qual(_, ty), optVar) =
108 :     pp (isFirst, ty, optVar)
109 : jhr 3955 | pp (isFirst, _, optVar) = ppVar (isFirst, optVar)
110 : jhr 3871 in
111 :     str (getBaseTy ty);
112 :     pp (true, ty, optVar)
113 :     end
114 : jhr 4317 fun ppTy' ty = ppTy (ty, NONE)
115 : jhr 3871 fun ppAttrs [] = ()
116 :     | ppAttrs attrs = (
117 :     ppList {pp=str, sep=sp, l = attrs};
118 :     sp())
119 :     fun ppDecl (inClass, dcl) = (case dcl
120 :     of CL.D_Pragma l => (
121 : jhr 4317 if inClass then PP.newline strm else ();
122 : jhr 3871 inHBox (fn () => (
123 :     str "#pragma";
124 : jhr 3999 List.app (fn s => (sp(); str s)) l)))
125 : jhr 3871 | CL.D_Comment l => List.app ppComLn l
126 : jhr 3999 | CL.D_Verbatim [] => ()
127 : jhr 4317 | CL.D_Verbatim l => (if inClass then PP.newline strm else (); List.app str l)
128 : jhr 4028 | CL.D_Var(attrs, ty, scopes, x, optInit) => (
129 : jhr 4317 if inClass then PP.newline strm else ();
130 : jhr 3871 inHBox (fn () => (
131 :     ppAttrs attrs;
132 : jhr 4028 ppTy (ty, SOME(scopes, x));
133 : jhr 3871 case optInit
134 :     of SOME init => (sp(); str "="; sp(); ppInit init)
135 :     | NONE => ()
136 :     (* end case *);
137 : jhr 3999 str ";")))
138 : jhr 3871 | CL.D_Proto(attrs, ty, f, params) => (
139 : jhr 4317 if inClass then PP.newline strm else ();
140 : jhr 3871 inHBox (fn () => (
141 :     ppAttrs attrs;
142 : jhr 4028 ppTy(ty, SOME([], f));
143 : jhr 3871 sp(); str "(";
144 : jhr 3994 ppCommaList {pp=ppParam, l=params};
145 : jhr 3999 str ");")))
146 : jhr 4028 | CL.D_Func(attrs, ty, scopes, f, params, body) => (
147 : jhr 4317 if inClass then PP.newline strm else ();
148 : jhr 3871 PP.openVBox strm indent0;
149 :     inHBox (fn () => (
150 :     ppAttrs attrs;
151 : jhr 4028 ppTy' ty;
152 : jhr 4317 sp (); ppQName (scopes, f);
153 : jhr 3871 sp(); str "(";
154 : jhr 3994 ppCommaList {pp=ppParam, l=params};
155 : jhr 3871 str ")"));
156 : jhr 4111 PP.newline strm;
157 : jhr 3994 ppBody body;
158 : jhr 3999 PP.closeBox strm)
159 : jhr 4028 | CL.D_Constr(attrs, scopes, cls, params, initsAndBody) => (
160 : jhr 4317 if inClass then PP.newline strm else ();
161 : jhr 3871 PP.openVBox strm indent0;
162 : jhr 3994 PP.openHBox strm;
163 : jhr 3871 ppAttrs attrs;
164 : jhr 4317 if inClass
165 :     then str cls
166 :     else ppQName (scopes, cls);
167 : jhr 3871 sp(); str "(";
168 : jhr 3994 ppCommaList {pp=ppParam, l=params};
169 : jhr 4317 str ")";
170 :     case initsAndBody
171 :     of SOME(inits, CL.S_Block[]) => (
172 :     if List.null inits
173 :     then (sp(); str "{ }"; PP.closeBox strm)
174 :     else (
175 :     PP.closeBox strm;
176 :     PP.openBox strm indent;
177 : jhr 4026 PP.newline strm;
178 :     str ":"; sp();
179 :     ppCommaList {pp = ppExp, l = inits};
180 : jhr 4317 PP.closeBox strm;
181 :     PP.newline strm;
182 :     str"{ }"))
183 :     | SOME(inits, body) => (
184 :     PP.closeBox strm;
185 :     if List.null inits
186 :     then ()
187 :     else (
188 :     PP.openBox strm indent;
189 :     PP.newline strm;
190 :     str ":"; sp();
191 :     ppCommaList {pp = ppExp, l = inits};
192 : jhr 4026 PP.closeBox strm);
193 : jhr 4317 PP.newline strm;
194 :     ppBody body)
195 :     | NONE => (str ";"; PP.closeBox strm)
196 :     (* end case *);
197 :     (* NOTE: HBox has been closed *)
198 : jhr 3999 PP.closeBox strm)
199 : jhr 4028 | CL.D_Destr(attrs, scopes, cls, body) => (
200 : jhr 4317 if inClass then PP.newline strm else ();
201 : jhr 3871 PP.openVBox strm indent0;
202 : jhr 3994 PP.openHBox strm;
203 : jhr 3871 ppAttrs attrs;
204 : jhr 4317 if inClass
205 :     then str("~" ^ cls)
206 :     else ppQName (scopes, "~" ^ cls);
207 : jhr 3871 sp();
208 : jhr 4317 case body
209 :     of NONE => (str "();"; PP.closeBox strm)
210 :     | SOME(CL.S_Block[]) => (str "() { }"; PP.closeBox strm)
211 :     | SOME body => (
212 :     str "()"; PP.closeBox strm; PP.newline strm; ppBody body)
213 :     (* end case *);
214 :     (* NOTE: HBox has been closed *)
215 : jhr 3999 PP.closeBox strm)
216 : jhr 3871 | CL.D_StructDef(SOME name, fields, NONE) => (
217 : jhr 4317 if inClass then PP.newline strm else ();
218 : jhr 3871 PP.openVBox strm indent0;
219 :     inHBox (fn () => (str "struct"; sp(); str name; sp(); str "{"));
220 :     PP.openVBox strm indent;
221 :     List.app (fn (ty, x) => (
222 :     PP.newline strm;
223 : jhr 4028 inHBox (fn () => (ppTy(ty, SOME([], x)); str ";"))))
224 : jhr 3871 fields;
225 :     PP.closeBox strm;
226 :     PP.newline strm;
227 :     str "};";
228 : jhr 3999 PP.closeBox strm)
229 : jhr 3871 | CL.D_StructDef(optStruct, fields, SOME tyName) => (
230 : jhr 4317 if inClass then PP.newline strm else ();
231 : jhr 3871 PP.openVBox strm indent0;
232 :     str "typedef struct {";
233 :     PP.openVBox strm indent;
234 :     List.app (fn (ty, x) => (
235 :     PP.newline strm;
236 : jhr 4028 inHBox (fn () => (ppTy(ty, SOME([], x)); str ";"))))
237 : jhr 3871 fields;
238 :     PP.closeBox strm;
239 :     PP.newline strm;
240 :     inHBox (fn () => (str "}"; sp(); str tyName; str ";"));
241 : jhr 4317 PP.closeBox strm)
242 :     | CL.D_StructDef(NONE, _, NONE) => raise Fail "unamed struct"
243 :     | CL.D_ClassDef{name, args, from, public, protected=[], private=[]} => (
244 :     if inClass then PP.newline strm else ();
245 : jhr 3871 PP.openVBox strm indent0;
246 :     inHBox (fn () => (
247 : jhr 4317 str "struct"; sp(); str name;
248 :     Option.map
249 :     (fn tys => (str "<"; ppCommaList {pp=ppTy', l=tys}; str ">"))
250 :     args;
251 :     Option.map (fn base => (sp(); str ":"; sp(); str base)) from;
252 :     sp(); str "{"));
253 : jhr 3871 PP.openVBox strm indent;
254 :     List.app (fn dcl => ppDecl (true, dcl)) public;
255 :     PP.closeBox strm;
256 :     PP.newline strm;
257 :     str "};";
258 : jhr 3999 PP.closeBox strm)
259 : jhr 4317 | CL.D_ClassDef{name, args, from, public, protected, private} =>
260 :     raise Fail "FIXME: ClassDef"
261 :     | CL.D_Template(params, dcl) => let
262 :     fun ppParam (CL.TypeParam name) = (str "typename"; sp(); str name)
263 :     | ppParam (CL.ConstParam(ty, name)) = (
264 :     str "const"; sp(); ppTy' ty; sp(); str name)
265 :     in
266 :     if inClass then PP.newline strm else ();
267 :     PP.openVBox strm indent0;
268 :     inHBox (fn () => (
269 :     str "template"; sp(); str "<";
270 :     ppCommaList {pp = ppParam, l = params};
271 :     str ">"));
272 :     PP.newline strm;
273 :     ppDecl (inClass, dcl);
274 :     PP.closeBox strm
275 :     end
276 :     | CL.D_Typedef(name, ty) => (
277 :     if inClass then PP.newline strm else ();
278 : jhr 3994 inHBox (fn () => (
279 : jhr 4005 str "using"; sp(); str name; sp(); str"="; sp(); ppTy' ty; str ";")))
280 : jhr 4317 | CL.D_Namespace(name, dcls) => (
281 :     if inClass then raise Fail "unexpected namespace inside class decl" else ();
282 : jhr 3996 PP.openVBox strm indent0;
283 :     inHBox (fn () => (str "namespace"; sp(); str name; sp(); str "{"));
284 :     PP.openVBox strm indent;
285 : jhr 3999 List.app
286 : jhr 4317 (fn CL.D_Verbatim[] => ()
287 :     | dcl => (PP.newline strm; ppDecl(false, dcl))
288 :     ) dcls;
289 : jhr 3996 PP.closeBox strm;
290 :     PP.newline strm;
291 :     inHBox (fn () => (str "}"; sp(); str("// namespace " ^ name)));
292 : jhr 4317 PP.closeBox strm)
293 : jhr 3871 (* end case *))
294 : jhr 4317 and ppBody (CL.S_Block stms) = ppBlock stms
295 :     | ppBody stm = ppBlock [stm]
296 : jhr 3871 and ppParam (CL.PARAM(attrs, ty, x)) = (
297 :     ppAttrs attrs;
298 : jhr 4028 ppTy(ty, SOME([], CL.varToString x)))
299 : jhr 3871 and ppInit init = (case init
300 :     of CL.I_Exp e => ppExp e
301 :     | CL.I_Exps fields => (
302 :     str "{";
303 :     PP.openHVBox strm indent;
304 :     List.app (fn init => (
305 :     PP.break strm;
306 :     inHBox (fn () => (ppInit init; str ","))))
307 :     fields;
308 :     PP.closeBox strm;
309 :     str "}")
310 :     | CL.I_Struct fields => (
311 :     str "{";
312 :     PP.openHVBox strm indent;
313 :     List.app (fn (lab, init) => (
314 :     PP.break strm;
315 :     inHBox (fn () => (
316 :     str("." ^ lab); sp(); str "="; sp(); ppInit init; str ","))))
317 :     fields;
318 :     PP.closeBox strm;
319 :     str "}")
320 :     | CL.I_Array elems => (
321 :     str "{";
322 :     PP.openHVBox strm indent;
323 :     List.app (fn (i, init) => (
324 :     PP.break strm;
325 :     inHBox (fn () => (
326 :     str(concat["[", Int.toString i, "]"]); sp(); str "="; sp();
327 :     ppInit init; str ","))))
328 :     elems;
329 :     PP.closeBox strm;
330 :     str "}")
331 : jhr 4317 | CL.I_Cons(ty, args) => (
332 : jhr 3871 PP.openHVBox strm indent;
333 : jhr 4317 ppTy' ty; ppArgs args; str ";";
334 :     PP.closeBox strm)
335 : jhr 3871 (* end case *))
336 :     and ppBlock stms = (
337 :     str "{";
338 :     PP.openVBox strm indent;
339 :     List.app (fn stm => (PP.newline strm; ppStm stm)) stms;
340 :     PP.closeBox strm;
341 :     PP.newline strm;
342 :     str "}")
343 :     and ppStm stm = (case stm
344 :     of CL.S_Block stms => ppBlock stms
345 :     | CL.S_Comment l => List.app ppCom l
346 :     | CL.S_Verbatim [] => ()
347 :     | CL.S_Verbatim (stm::stms) => (
348 :     str stm;
349 :     List.app (fn stm => (PP.newline strm; str stm)) stms)
350 :     | CL.S_Decl(attrs, ty, x, NONE) => inHBox (fn () => (
351 :     ppAttrs attrs;
352 : jhr 4028 ppTy(ty, SOME([], x)); str ";"))
353 : jhr 3871 | CL.S_Decl(attrs, ty, x, SOME e) => inHBox (fn () => (
354 :     ppAttrs attrs;
355 : jhr 4028 ppTy(ty, SOME([], x)); sp(); str "="; sp(); ppInit e; str ";"))
356 : jhr 3871 | CL.S_Exp e => inHBox (fn () => (ppExp e; str ";"))
357 :     | CL.S_If(e, blk, CL.S_Block[]) =>
358 :     inHBox (fn () => (str "if"; sp(); ppExp e; ppStmAsBlock blk))
359 :     | CL.S_If(e, blk1, stm as CL.S_If _) => (
360 :     PP.openVBox strm indent0;
361 :     inHBox (fn () => (str "if"; sp(); ppExp e; ppStmAsBlock blk1));
362 :     PP.newline strm;
363 :     PP.closeBox strm;
364 :     inHBox (fn () => (str "else"; sp(); ppStm stm)))
365 :     | CL.S_If(e, blk1, blk2) => (
366 :     PP.openVBox strm indent0;
367 :     inHBox (fn () => (str "if"; sp(); ppExp e; ppStmAsBlock blk1));
368 :     PP.newline strm;
369 :     inHBox (fn () => (str "else"; ppStmAsBlock blk2));
370 :     PP.closeBox strm)
371 :     | CL.S_While(e, blk) =>
372 :     inHBox (fn () => (str "while"; sp(); ppExp e; ppStmAsBlock blk))
373 :     | CL.S_DoWhile(blk, e) =>
374 :     inHBox (fn () => (
375 :     str "do"; ppStmAsBlock blk; sp(); str "while"; sp(); ppExp e))
376 : jhr 3996 | CL.S_For(ty, dcls, cond, incrs, blk) => inHBox (fn () => (
377 : jhr 4317 str "for"; sp(); str "(";
378 :     case dcls
379 :     of (x, e)::rest => (
380 :     ppTy(ty, SOME([], x)); sp(); str "="; sp(); ppExp e;
381 :     List.app
382 :     (fn (x, e) => (str ","; sp(); str x; sp(); str "="; sp(); ppExp e))
383 :     rest)
384 :     | [] => ()
385 :     (* end case *);
386 :     str ";"; sp();
387 :     ppExp cond; str ";"; sp();
388 :     ppList {pp = ppExp, sep = fn () => str ",", l = incrs};
389 :     str ")";
390 :     ppStmAsBlock blk))
391 : jhr 3871 | CL.S_Return(SOME e) => inHBox (fn () => (str "return"; sp(); ppExp e; str ";"))
392 :     | CL.S_Return _ => str "return;"
393 :     | CL.S_Break => str "break;"
394 :     | CL.S_Continue => str "continue;"
395 : jhr 4855 | CL.S_Delete(isArr, e) => inHBox (fn () => (
396 :     if isArr then str "delete[]" else str "delete";
397 :     sp(); ppExp e; str ";"))
398 : jhr 3897 | CL.S_KernCall _ => raise Fail "unexpected KernCall in C++ code"
399 : jhr 3871 (* end case *))
400 :     (* force printing "{" "}" around a statement *)
401 :     and ppStmAsBlock (CL.S_Block stms) = (sp(); ppBlock stms)
402 :     | ppStmAsBlock stm = (sp(); ppBlock [stm])
403 :     and ppExp e = (case e
404 :     of CL.E_Grp e => (str "("; ppExp e; str ")")
405 :     | CL.E_AssignOp(lhs, rator, rhs) => (
406 :     ppExp lhs; sp(); str(CL.assignopToString rator); sp(); ppExp rhs)
407 :     | CL.E_Cond(e1, e2, e3) => (
408 :     ppExp e1; sp(); str "?"; sp(); ppExp e2; sp(); str ":"; sp(); ppExp e3)
409 : jhr 4287 | CL.E_BinOp(e1, rator, e2) => (
410 : jhr 4317 ppExp e1; sp(); str(CL.binopToString rator); sp(); ppExp e2)
411 : jhr 3871 | CL.E_UnOp(rator, e) => (str(CL.unopToString rator); ppExp e)
412 :     | CL.E_PostOp(e, rator) => (ppExp e; str(CL.postopToString rator))
413 :     | CL.E_Apply(e, args) => (ppExp e; ppArgs args)
414 : jhr 4065 | CL.E_TApply(prefix, f, tys, args) => (
415 : jhr 4317 ppQName(prefix, f); str "<";
416 :     ppCommaList {
417 :     pp = fn ty => (PP.openHBox strm; ppTy' ty; PP.closeBox strm),
418 :     l = tys
419 :     };
420 :     str ">"; ppArgs args)
421 : jhr 4065 | CL.E_QId(prefix, id) => ppQName(prefix, id)
422 : jhr 4005 | CL.E_Cons(ty, args) => (ppTy' ty; ppArgs args)
423 : jhr 3871 | CL.E_New(ty, args) => (
424 : jhr 4317 str "new"; sp(); ppTy' ty;
425 :     case (ty, args)
426 :     of (CL.T_Named ty, []) => str ty
427 :     | (CL.T_Template _, []) => ppTy' ty
428 :     | (CL.T_Named ty, args) => (str ty; ppArgs args)
429 :     | (CL.T_Template _, args) => (ppTy' ty; ppArgs args)
430 :     | (ty, []) => ppTy' ty
431 :     | _ => raise Fail "bogus new"
432 :     (* end case *))
433 : jhr 3871 | CL.E_Subscript(e1, e2) => (ppExp e1; str "["; ppExp e2; str "]")
434 :     | CL.E_Select(e, f) => (ppExp e; str "."; str f)
435 :     | CL.E_Indirect(e, f) => (ppExp e; str "->"; str f)
436 : jhr 4005 | CL.E_Cast(ty, e) => (str "("; ppTy' ty; str ")"; ppExp e)
437 : jhr 3924 | CL.E_XCast(c, ty, e) => (
438 : jhr 4317 str c; str "<"; ppTy' ty; str ">("; ppExp e; str ")")
439 :     | CL.E_Vec(ty, args) => (
440 :     (* GCC vector syntax: "__extension__ (ty){a, b, ...}" *)
441 :     str "__extension__"; sp(); str "("; ppTy' ty; str ")";
442 :     str "{";
443 :     PP.openHOVBox strm indent;
444 :     PP.cut strm;
445 :     ppCommaList {
446 :     pp = fn e => (PP.openHBox strm; ppExp e; PP.closeBox strm),
447 :     l = args
448 :     };
449 :     str "}";
450 :     PP.closeBox strm)
451 : jhr 5108 | CL.E_Array exps => (
452 :     str "{";
453 :     PP.openHVBox strm indent;
454 :     List.app (fn e => (
455 :     PP.break strm;
456 :     inHBox (fn () => (ppExp e; str ","))))
457 :     exps;
458 :     PP.closeBox strm;
459 :     str "}")
460 : jhr 3871 | CL.E_Var x => str(CL.varToString x)
461 :     | CL.E_Int(n, CL.T_Num(RawTypes.RT_Int64)) =>
462 :     str(IntLit.toString n ^ "l")
463 :     | CL.E_Int(n, _) => str(IntLit.toString n)
464 :     | CL.E_Flt(f, ty) => let
465 :     val isDouble = (case ty
466 :     of CL.T_Num(RawTypes.RT_Float) => false
467 :     | _ => true
468 :     (* end case *))
469 :     (* NOTE: the CLang.mkFlt function guarantees that f is non-negative *)
470 :     val f = if RealLit.same(RealLit.posInf, f)
471 :     then if isDouble
472 :     then "HUGE_VAL"
473 :     else "HUGE_VALF"
474 :     else if RealLit.same(RealLit.nan, f)
475 :     then if isDouble
476 :     then "std::nan(\"\")"
477 :     else "std::nanf(\"\")"
478 :     else if isDouble
479 :     then RealLit.toString f
480 :     else RealLit.toString f ^ "f"
481 :     in
482 :     str f
483 :     end
484 :     | CL.E_Bool b => str(Bool.toString b)
485 :     | CL.E_Str s => str(concat["\"", String.toCString s, "\""])
486 :     | CL.E_Char c => str(concat["'", Char.toCString c, "'"])
487 : jhr 4005 | CL.E_Sizeof ty => (str "sizeof("; ppTy' ty; str ")")
488 : jhr 3871 (* end case *))
489 :     and ppArgs args = (
490 :     str "(";
491 :     PP.openHOVBox strm indent;
492 :     PP.cut strm;
493 : jhr 3994 ppCommaList {
494 : jhr 3871 pp = fn e => (PP.openHBox strm; ppExp e; PP.closeBox strm),
495 :     l = args
496 :     };
497 :     str ")";
498 :     PP.closeBox strm)
499 :     in
500 : jhr 4317 PP.openVBox strm indent0;
501 : jhr 3999 ppDecl (false, decl);
502 : jhr 4317 PP.newline strm;
503 :     PP.closeBox strm
504 : jhr 3871 end
505 :    
506 :     end

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