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 5584 - (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 :     PP.openVBox strm indent0;
302 :     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 :     ppCon con;
313 :     List.app (fn c => (str ","; sp(); ppCon con)) conr;
314 :     PP.closeBox strm;
315 :     str "};";
316 :     PP.closeBox strm
317 :     end
318 : jhr 4317 | CL.D_Template(params, dcl) => let
319 :     fun ppParam (CL.TypeParam name) = (str "typename"; sp(); str name)
320 :     | ppParam (CL.ConstParam(ty, name)) = (
321 : jhr 5584 str "const"; sp(); ppTy ty; sp(); str name)
322 : jhr 4317 in
323 : jhr 5584 if inClass then nl() else ();
324 : jhr 4317 PP.openVBox strm indent0;
325 :     inHBox (fn () => (
326 :     str "template"; sp(); str "<";
327 :     ppCommaList {pp = ppParam, l = params};
328 :     str ">"));
329 : jhr 5584 nl();
330 : jhr 4317 ppDecl (inClass, dcl);
331 :     PP.closeBox strm
332 :     end
333 :     | CL.D_Typedef(name, ty) => (
334 : jhr 5584 if inClass then nl() else ();
335 : jhr 3994 inHBox (fn () => (
336 : jhr 5584 str "using"; sp(); str name; sp(); str"="; sp(); ppTy ty; str ";")))
337 : jhr 4317 | CL.D_Namespace(name, dcls) => (
338 :     if inClass then raise Fail "unexpected namespace inside class decl" else ();
339 : jhr 3996 PP.openVBox strm indent0;
340 :     inHBox (fn () => (str "namespace"; sp(); str name; sp(); str "{"));
341 :     PP.openVBox strm indent;
342 : jhr 3999 List.app
343 : jhr 4317 (fn CL.D_Verbatim[] => ()
344 : jhr 5584 | dcl => (nl(); ppDecl(false, dcl))
345 : jhr 4317 ) dcls;
346 : jhr 3996 PP.closeBox strm;
347 : jhr 5584 nl();
348 : jhr 3996 inHBox (fn () => (str "}"; sp(); str("// namespace " ^ name)));
349 : jhr 4317 PP.closeBox strm)
350 : jhr 3871 (* end case *))
351 : jhr 4317 and ppBody (CL.S_Block stms) = ppBlock stms
352 :     | ppBody stm = ppBlock [stm]
353 : jhr 3871 and ppParam (CL.PARAM(attrs, ty, x)) = (
354 :     ppAttrs attrs;
355 : jhr 5584 ppTyAndVar(ty, ([], CL.varToString x)))
356 : jhr 3871 and ppInit init = (case init
357 :     of CL.I_Exp e => ppExp e
358 :     | CL.I_Exps fields => (
359 :     str "{";
360 :     PP.openHVBox strm indent;
361 :     List.app (fn init => (
362 :     PP.break strm;
363 :     inHBox (fn () => (ppInit init; str ","))))
364 :     fields;
365 :     PP.closeBox strm;
366 :     str "}")
367 :     | CL.I_Struct fields => (
368 :     str "{";
369 :     PP.openHVBox strm indent;
370 :     List.app (fn (lab, init) => (
371 :     PP.break strm;
372 :     inHBox (fn () => (
373 :     str("." ^ lab); sp(); str "="; sp(); ppInit init; str ","))))
374 :     fields;
375 :     PP.closeBox strm;
376 :     str "}")
377 :     | CL.I_Array elems => (
378 :     str "{";
379 :     PP.openHVBox strm indent;
380 :     List.app (fn (i, init) => (
381 :     PP.break strm;
382 :     inHBox (fn () => (
383 :     str(concat["[", Int.toString i, "]"]); sp(); str "="; sp();
384 :     ppInit init; str ","))))
385 :     elems;
386 :     PP.closeBox strm;
387 :     str "}")
388 : jhr 4317 | CL.I_Cons(ty, args) => (
389 : jhr 3871 PP.openHVBox strm indent;
390 : jhr 5584 ppTy ty; ppArgs args; str ";";
391 : jhr 4317 PP.closeBox strm)
392 : jhr 3871 (* end case *))
393 :     and ppBlock stms = (
394 :     str "{";
395 :     PP.openVBox strm indent;
396 : jhr 5584 List.app (fn stm => (nl(); ppStm stm)) stms;
397 : jhr 3871 PP.closeBox strm;
398 : jhr 5584 nl();
399 : jhr 3871 str "}")
400 :     and ppStm stm = (case stm
401 :     of CL.S_Block stms => ppBlock stms
402 :     | CL.S_Comment l => List.app ppCom l
403 :     | CL.S_Verbatim [] => ()
404 :     | CL.S_Verbatim (stm::stms) => (
405 :     str stm;
406 : jhr 5584 List.app (fn stm => (nl(); str stm)) stms)
407 : jhr 3871 | CL.S_Decl(attrs, ty, x, NONE) => inHBox (fn () => (
408 :     ppAttrs attrs;
409 : jhr 5584 ppTyAndVar(ty, ([], x)); str ";"))
410 : jhr 3871 | CL.S_Decl(attrs, ty, x, SOME e) => inHBox (fn () => (
411 :     ppAttrs attrs;
412 : jhr 5584 ppTyAndVar(ty, ([], x)); sp(); str "="; sp(); ppInit e; str ";"))
413 : jhr 3871 | CL.S_Exp e => inHBox (fn () => (ppExp e; str ";"))
414 :     | CL.S_If(e, blk, CL.S_Block[]) =>
415 :     inHBox (fn () => (str "if"; sp(); ppExp e; ppStmAsBlock blk))
416 :     | CL.S_If(e, blk1, stm as CL.S_If _) => (
417 :     PP.openVBox strm indent0;
418 :     inHBox (fn () => (str "if"; sp(); ppExp e; ppStmAsBlock blk1));
419 : jhr 5584 nl();
420 : jhr 3871 PP.closeBox strm;
421 :     inHBox (fn () => (str "else"; sp(); ppStm stm)))
422 :     | CL.S_If(e, blk1, blk2) => (
423 :     PP.openVBox strm indent0;
424 :     inHBox (fn () => (str "if"; sp(); ppExp e; ppStmAsBlock blk1));
425 : jhr 5584 nl();
426 : jhr 3871 inHBox (fn () => (str "else"; ppStmAsBlock blk2));
427 :     PP.closeBox strm)
428 : jhr 5584 | CL.S_Switch(e, cases) => let
429 :     fun ppCase (labels, stms) = (
430 :     if List.null labels
431 :     then (nl(); str "default:")
432 :     else List.app
433 :     (fn lab => inHBox(fn () => (
434 :     nl(); str "case"; sp(); str lab; str ":")))
435 :     labels;
436 :     PP.openVBox strm indent2;
437 :     List.app (fn stm => (nl(); ppStm stm)) stms;
438 :     PP.closeBox strm)
439 :     in
440 :     PP.openVBox strm indent0;
441 :     inHBox (fn () => (str "switch"; sp(); ppExp e; sp(); str "{"));
442 :     PP.openVBox strm indent2;
443 :     List.app ppCase cases;
444 :     PP.closeBox strm;
445 :     nl (); str "}";
446 :     PP.closeBox strm
447 :     end
448 : jhr 3871 | CL.S_While(e, blk) =>
449 :     inHBox (fn () => (str "while"; sp(); ppExp e; ppStmAsBlock blk))
450 :     | CL.S_DoWhile(blk, e) =>
451 :     inHBox (fn () => (
452 :     str "do"; ppStmAsBlock blk; sp(); str "while"; sp(); ppExp e))
453 : jhr 3996 | CL.S_For(ty, dcls, cond, incrs, blk) => inHBox (fn () => (
454 : jhr 4317 str "for"; sp(); str "(";
455 :     case dcls
456 :     of (x, e)::rest => (
457 : jhr 5584 ppTyAndVar(ty, ([], x)); sp(); str "="; sp(); ppExp e;
458 : jhr 4317 List.app
459 :     (fn (x, e) => (str ","; sp(); str x; sp(); str "="; sp(); ppExp e))
460 :     rest)
461 :     | [] => ()
462 :     (* end case *);
463 :     str ";"; sp();
464 :     ppExp cond; str ";"; sp();
465 :     ppList {pp = ppExp, sep = fn () => str ",", l = incrs};
466 :     str ")";
467 :     ppStmAsBlock blk))
468 : jhr 3871 | CL.S_Return(SOME e) => inHBox (fn () => (str "return"; sp(); ppExp e; str ";"))
469 :     | CL.S_Return _ => str "return;"
470 :     | CL.S_Break => str "break;"
471 :     | CL.S_Continue => str "continue;"
472 : jhr 5113 | CL.S_Delete(isArr, e) => inHBox (fn () => (
473 :     if isArr then str "delete[]" else str "delete";
474 :     sp(); ppExp e; str ";"))
475 : jhr 3897 | CL.S_KernCall _ => raise Fail "unexpected KernCall in C++ code"
476 : jhr 3871 (* end case *))
477 :     (* force printing "{" "}" around a statement *)
478 :     and ppStmAsBlock (CL.S_Block stms) = (sp(); ppBlock stms)
479 :     | ppStmAsBlock stm = (sp(); ppBlock [stm])
480 :     and ppExp e = (case e
481 :     of CL.E_Grp e => (str "("; ppExp e; str ")")
482 :     | CL.E_AssignOp(lhs, rator, rhs) => (
483 :     ppExp lhs; sp(); str(CL.assignopToString rator); sp(); ppExp rhs)
484 :     | CL.E_Cond(e1, e2, e3) => (
485 :     ppExp e1; sp(); str "?"; sp(); ppExp e2; sp(); str ":"; sp(); ppExp e3)
486 : jhr 4287 | CL.E_BinOp(e1, rator, e2) => (
487 : jhr 4317 ppExp e1; sp(); str(CL.binopToString rator); sp(); ppExp e2)
488 : jhr 3871 | CL.E_UnOp(rator, e) => (str(CL.unopToString rator); ppExp e)
489 :     | CL.E_PostOp(e, rator) => (ppExp e; str(CL.postopToString rator))
490 :     | CL.E_Apply(e, args) => (ppExp e; ppArgs args)
491 : jhr 4065 | CL.E_TApply(prefix, f, tys, args) => (
492 : jhr 4317 ppQName(prefix, f); str "<";
493 :     ppCommaList {
494 : jhr 5584 pp = fn ty => (PP.openHBox strm; ppTy ty; PP.closeBox strm),
495 : jhr 4317 l = tys
496 :     };
497 :     str ">"; ppArgs args)
498 : jhr 4065 | CL.E_QId(prefix, id) => ppQName(prefix, id)
499 : jhr 5584 | CL.E_Cons(ty, args) => (ppTy ty; ppArgs args)
500 : jhr 3871 | CL.E_New(ty, args) => (
501 : jhr 5584 str "new"; sp(); ppTy ty;
502 : jhr 4317 case (ty, args)
503 :     of (CL.T_Named ty, []) => str ty
504 : jhr 5584 | (CL.T_Template _, []) => ppTy ty
505 : jhr 4317 | (CL.T_Named ty, args) => (str ty; ppArgs args)
506 : jhr 5584 | (CL.T_Template _, args) => (ppTy ty; ppArgs args)
507 :     | (ty, []) => ppTy ty
508 : jhr 4317 | _ => raise Fail "bogus new"
509 :     (* end case *))
510 : jhr 3871 | CL.E_Subscript(e1, e2) => (ppExp e1; str "["; ppExp e2; str "]")
511 :     | CL.E_Select(e, f) => (ppExp e; str "."; str f)
512 :     | CL.E_Indirect(e, f) => (ppExp e; str "->"; str f)
513 : jhr 5584 | CL.E_Cast(ty, e) => (str "("; ppTy ty; str ")"; ppExp e)
514 : jhr 3924 | CL.E_XCast(c, ty, e) => (
515 : jhr 5584 str c; str "<"; ppTy ty; str ">("; ppExp e; str ")")
516 : jhr 4317 | CL.E_Vec(ty, args) => (
517 :     (* GCC vector syntax: "__extension__ (ty){a, b, ...}" *)
518 : jhr 5584 str "__extension__"; sp(); str "("; ppTy ty; str ")";
519 : jhr 4317 str "{";
520 :     PP.openHOVBox strm indent;
521 :     PP.cut strm;
522 :     ppCommaList {
523 :     pp = fn e => (PP.openHBox strm; ppExp e; PP.closeBox strm),
524 :     l = args
525 :     };
526 :     str "}";
527 :     PP.closeBox strm)
528 : jhr 5108 | CL.E_Array exps => (
529 :     str "{";
530 :     PP.openHVBox strm indent;
531 :     List.app (fn e => (
532 :     PP.break strm;
533 :     inHBox (fn () => (ppExp e; str ","))))
534 :     exps;
535 :     PP.closeBox strm;
536 :     str "}")
537 : jhr 3871 | CL.E_Var x => str(CL.varToString x)
538 :     | CL.E_Int(n, CL.T_Num(RawTypes.RT_Int64)) =>
539 :     str(IntLit.toString n ^ "l")
540 :     | CL.E_Int(n, _) => str(IntLit.toString n)
541 :     | CL.E_Flt(f, ty) => let
542 :     val isDouble = (case ty
543 :     of CL.T_Num(RawTypes.RT_Float) => false
544 :     | _ => true
545 :     (* end case *))
546 :     (* NOTE: the CLang.mkFlt function guarantees that f is non-negative *)
547 :     val f = if RealLit.same(RealLit.posInf, f)
548 :     then if isDouble
549 :     then "HUGE_VAL"
550 :     else "HUGE_VALF"
551 :     else if RealLit.same(RealLit.nan, f)
552 :     then if isDouble
553 :     then "std::nan(\"\")"
554 :     else "std::nanf(\"\")"
555 :     else if isDouble
556 :     then RealLit.toString f
557 :     else RealLit.toString f ^ "f"
558 :     in
559 :     str f
560 :     end
561 :     | CL.E_Bool b => str(Bool.toString b)
562 :     | CL.E_Str s => str(concat["\"", String.toCString s, "\""])
563 :     | CL.E_Char c => str(concat["'", Char.toCString c, "'"])
564 : jhr 5584 | CL.E_Sizeof ty => (str "sizeof("; ppTy ty; str ")")
565 : jhr 3871 (* end case *))
566 :     and ppArgs args = (
567 :     str "(";
568 :     PP.openHOVBox strm indent;
569 :     PP.cut strm;
570 : jhr 3994 ppCommaList {
571 : jhr 3871 pp = fn e => (PP.openHBox strm; ppExp e; PP.closeBox strm),
572 :     l = args
573 :     };
574 :     str ")";
575 :     PP.closeBox strm)
576 :     in
577 : jhr 4317 PP.openVBox strm indent0;
578 : jhr 3999 ppDecl (false, decl);
579 : jhr 5584 nl();
580 : jhr 4317 PP.closeBox strm
581 : jhr 3871 end
582 :    
583 :     end

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