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

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