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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3993, Fri Jun 17 22:09:06 2016 UTC revision 3994, Sat Jun 18 18:41:33 2016 UTC
# Line 10  Line 10 
10    
11  structure PrintAsCxx : sig  structure PrintAsCxx : sig
12    
13        val rawTyName : RawTypes.t -> string
14    
15      val output : TextIOPP.stream * CLang.decl -> unit      val output : TextIOPP.stream * CLang.decl -> unit
16    
17    end = struct    end = struct
# Line 20  Line 22 
22      val indent0 = (PP.Abs 0)      val indent0 = (PP.Abs 0)
23      val indent = (PP.Abs 4)     (* standard indentation amount *)      val indent = (PP.Abs 4)     (* standard indentation amount *)
24    
25        fun rawTyName rty = (case rty
26               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    
38      fun output (strm, decl) = let      fun output (strm, decl) = let
39            val str = PP.string strm            val str = PP.string strm
40            fun sp () = PP.space strm 1            fun sp () = PP.space strm 1
# Line 33  Line 48 
48                  in                  in
49                    ppList' l                    ppList' l
50                  end                  end
51              fun ppCommaList {pp, l} = ppList {pp = pp, sep = fn () => (str ","; sp()), l = l}
52            fun ppTy (ty, optVar) = let            fun ppTy (ty, optVar) = let
53                  fun rawTy rty = (case rty                  fun getBaseTy (CL.T_Num rty) = rawTyName rty
54                         of RawTypes.RT_Int8 => "int8_t"                    | getBaseTy (CL.T_Const(CL.T_Num rty)) = "const " ^ rawTyName rty
                         | RawTypes.RT_UInt8 => "uint8_t"  
                         | RawTypes.RT_Int16 => "int16_t"  
                         | RawTypes.RT_UInt16 => "uint16_t"  
                         | RawTypes.RT_Int32 => "int32_t"  
                         | RawTypes.RT_UInt32 => "uint32_t"  
                         | RawTypes.RT_Int64 => "int64_t"  
                         | RawTypes.RT_UInt64 => "uint64_t"  
                         | RawTypes.RT_Float => "float"  
                         | RawTypes.RT_Double => "double"  
                       (* end case *))  
                 fun getBaseTy (CL.T_Num rty) = rawTy rty  
                   | getBaseTy (CL.T_Const(CL.T_Num rty)) = "const " ^ rawTy rty  
55                    | getBaseTy (CL.T_Const(CL.T_Named ty)) = "const " ^ ty                    | getBaseTy (CL.T_Const(CL.T_Named ty)) = "const " ^ ty
56                    | getBaseTy (CL.T_Const ty) = getBaseTy ty                    | getBaseTy (CL.T_Const ty) = getBaseTy ty
57                    | getBaseTy (CL.T_Ptr ty) = getBaseTy ty                    | getBaseTy (CL.T_Ptr ty) = getBaseTy ty
# Line 121  Line 125 
125                          ppAttrs attrs;                          ppAttrs attrs;
126                          ppTy(ty, SOME f);                          ppTy(ty, SOME f);
127                          sp(); str "(";                          sp(); str "(";
128                          ppList {pp=ppParam, sep=fn () => (str ","; sp()), l=params};                          ppCommaList {pp=ppParam, l=params};
129                          str ");"));                          str ");"));
130                        PP.newline strm)                        PP.newline strm)
131                    | CL.D_Func(attrs, ty, f, params, body) => (                    | CL.D_Func(attrs, ty, f, params, body) => (
# Line 130  Line 134 
134                            ppAttrs attrs;                            ppAttrs attrs;
135                            ppTy(ty, SOME f);                            ppTy(ty, SOME f);
136                            sp(); str "(";                            sp(); str "(";
137                            ppList {pp=ppParam, sep=fn () => (str ","; sp()), l=params};                            ppCommaList {pp=ppParam, l=params};
138                            str ")"));                            str ")"));
139                          PP.newline strm;                          PP.newline strm;
140                          ppBlock (case body of CL.S_Block stms => stms | stm => [stm]);                          ppBody body;
141                        PP.closeBox strm;                        PP.closeBox strm;
142                        PP.newline strm)                        PP.newline strm)
143                    | CL.D_Constr(attrs, namespace, cls, params, inits, body) => (                    | CL.D_Constr(attrs, namespace, cls, params, inits, body) => (
144                        PP.openVBox strm indent0;                        PP.openVBox strm indent0;
145                          inHBox (fn () => (                          PP.openHBox strm;
146                            ppAttrs attrs;                            ppAttrs attrs;
147                            if inClass                            if inClass
148                              then str cls                              then str cls
# Line 146  Line 150 
150                                Option.app (fn ns => (str ns; str "::")) namespace;                                Option.app (fn ns => (str ns; str "::")) namespace;
151                                str cls; str "::"; str cls);                                str cls; str "::"; str cls);
152                            sp(); str "(";                            sp(); str "(";
153                            ppList {pp=ppParam, sep=fn () => (str ","; sp()), l=params};                            ppCommaList {pp=ppParam, l=params};
154                            if Option.isNone body then str ");" else str ")"));                            if Option.isNone body then str ");" else str ")";
155                          case body                          case body
156                           of SOME body => (                             of SOME(CL.S_Block[]) => (
157                                    if List.null inits
158                                      then (sp(); str "{ }"; PP.closeBox strm)
159                                      else (
160                                        PP.closeBox strm;
161                                        PP.newline strm;
162    (* FIXME: inits *)
163                                        str"{ }"))
164                                | SOME body => (
165                                    PP.closeBox strm;
166                                PP.newline strm;                                PP.newline strm;
167  (* TODO inits *)  (* FIXME inits *)
168                                ppBlock (case body of CL.S_Block stms => stms | stm => [stm]))                                  ppBody body)
169                            | NONE => ()                            | NONE => ()
170                          (* end case *);                          (* end case *);
171                            (* NOTE: HBox has been closed *)
172                        PP.closeBox strm;                        PP.closeBox strm;
173                        PP.newline strm)                        PP.newline strm)
174                    | CL.D_Destr(attrs, namespace, cls, body) => (                    | CL.D_Destr(attrs, namespace, cls, body) => (
175                        PP.openVBox strm indent0;                        PP.openVBox strm indent0;
176                          inHBox (fn () => (                          PP.openHBox strm;
177                            ppAttrs attrs;                            ppAttrs attrs;
178                            if inClass                            if inClass
179                              then (str "~"; str cls)                              then (str "~"; str cls)
# Line 167  Line 181 
181                                Option.app (fn ns => (str ns; str "::")) namespace;                                Option.app (fn ns => (str ns; str "::")) namespace;
182                                str "~"; str cls; str "::"; str cls);                                str "~"; str cls; str "::"; str cls);
183                            sp();                            sp();
                           if Option.isNone body then str "();" else str "()"));  
184                          case body                          case body
185                           of SOME(CL.S_Block stms) => (PP.newline strm; ppBlock stms)                             of NONE => (str "();"; PP.closeBox strm)
186                            | SOME stm => (PP.newline strm; ppBlock [stm])                              | SOME(CL.S_Block[]) => (str "() { }"; PP.closeBox strm)
187                            | NONE => ()                              | SOME body => (
188                                    str "()"; PP.closeBox strm; PP.newline strm; ppBody body)
189                          (* end case *);                          (* end case *);
190                            (* NOTE: HBox has been closed *)
191                        PP.closeBox strm;                        PP.closeBox strm;
192                        PP.newline strm)                        PP.newline strm)
193                    | CL.D_StructDef(SOME name, fields, NONE) => (                    | CL.D_StructDef(SOME name, fields, NONE) => (
# Line 202  Line 217 
217                          PP.closeBox strm;                          PP.closeBox strm;
218                        PP.newline strm)                        PP.newline strm)
219                    | CL.D_StructDef(NONE, _, NONE) => raise Fail "unamed struct"                    | CL.D_StructDef(NONE, _, NONE) => raise Fail "unamed struct"
220                    | CL.D_ClassDef{name, from, public, protected=[], private=[]} => (                    | CL.D_ClassDef{name, args, from, public, protected=[], private=[]} => (
221                        PP.openVBox strm indent0;                        PP.openVBox strm indent0;
222                          inHBox (fn () => (                          inHBox (fn () => (
223                            str "struct"; sp(); str name;                            str "struct"; sp(); str name;
224                              Option.map (fn tys => (str "<"; str ">")) args;
225                            Option.map (fn base => (sp(); str ":"; sp(); str base)) from;                            Option.map (fn base => (sp(); str ":"; sp(); str base)) from;
226                            sp(); str "{"));                            sp(); str "{"));
227                          PP.openVBox strm indent;                          PP.openVBox strm indent;
# Line 216  Line 232 
232                          str "};";                          str "};";
233                        PP.closeBox strm;                        PP.closeBox strm;
234                        PP.newline strm)                        PP.newline strm)
235                    | CL.D_ClassDef{name, from, public, protected, private} =>                    | CL.D_ClassDef{name, args, from, public, protected, private} =>
236                        raise Fail "FIXME: ClassDef"                        raise Fail "FIXME: ClassDef"
237                    | CL.D_Template(params, dcl) => let                    | CL.D_Template(params, dcl) => let
238                        fun ppParam (CL.TypeParam name) = (str "typename"; sp(); str name)                        fun ppParam (CL.TypeParam name) = (str "typename"; sp(); str name)
# Line 226  Line 242 
242                          PP.openVBox strm indent0;                          PP.openVBox strm indent0;
243                            inHBox (fn () => (                            inHBox (fn () => (
244                              str "template"; sp(); str "<";                              str "template"; sp(); str "<";
245                              ppList {pp = ppParam, sep = fn () => str ",", l = params};                              ppCommaList {pp = ppParam, l = params};
246                              str ">"));                              str ">"));
247                            PP.newline strm;                            PP.newline strm;
248                            ppDecl (inClass, dcl);                            ppDecl (inClass, dcl);
249                          PP.closeBox strm                          PP.closeBox strm
250                        end                        end
251                      | CL.D_Typedef(name, ty) => (
252                          inHBox (fn () => (
253                            str "using"; sp(); str name; sp(); str"="; sp(); ppTy(ty, NONE); str ";"));
254                          PP.newline strm)
255                  (* end case *))                  (* end case *))
256              and ppBody (CL.S_Block stms) = ppBlock stms
257                | ppBody stm = ppBlock [stm]
258            and ppParam (CL.PARAM(attrs, ty, x)) = (            and ppParam (CL.PARAM(attrs, ty, x)) = (
259                  ppAttrs attrs;                  ppAttrs attrs;
260                  ppTy(ty, SOME(CL.varToString x)))                  ppTy(ty, SOME(CL.varToString x)))
# Line 321  Line 343 
343                        in                        in
344                          inHBox (fn () => (                          inHBox (fn () => (
345                            str "for"; sp(); str "(";                            str "for"; sp(); str "(";
346                            ppList {pp = ppInit, sep = fn () => str ",", l = inits};                            ppCommaList {pp = ppInit, l = inits};
347                            str ";"; sp();                            str ";"; sp();
348                            ppExp cond; str ";"; sp();                            ppExp cond; str ";"; sp();
349                            ppList {pp = ppExp, sep = fn () => str ",", l = incrs};                            ppCommaList {pp = ppExp, l = incrs};
350                            str ")";                            str ")";
351                            ppStmAsBlock blk))                            ppStmAsBlock blk))
352                        end                        end
# Line 349  Line 371 
371                    | CL.E_Apply(e, args) => (ppExp e; ppArgs args)                    | CL.E_Apply(e, args) => (ppExp e; ppArgs args)
372                    | CL.E_TApply(f, tys, args) => (                    | CL.E_TApply(f, tys, args) => (
373                        str f; str "<";                        str f; str "<";
374                        ppList {                        ppCommaList {
375                            pp = fn ty => (PP.openHBox strm; ppTy(ty, NONE); PP.closeBox strm),                            pp = fn ty => (PP.openHBox strm; ppTy(ty, NONE); PP.closeBox strm),
                           sep = fn () => (str ","; sp()),  
376                            l = tys                            l = tys
377                          };                          };
378                        str ">"; ppArgs args)                        str ">"; ppArgs args)
# Line 378  Line 399 
399                        str "{";                        str "{";
400                        PP.openHOVBox strm indent;                        PP.openHOVBox strm indent;
401                          PP.cut strm;                          PP.cut strm;
402                          ppList {                          ppCommaList {
403                              pp = fn e => (PP.openHBox strm; ppExp e; PP.closeBox strm),                              pp = fn e => (PP.openHBox strm; ppExp e; PP.closeBox strm),
                             sep = fn () => (str ","; sp()),  
404                              l = args                              l = args
405                            };                            };
406                          str "}";                          str "}";
# Line 418  Line 438 
438                  str "(";                  str "(";
439                  PP.openHOVBox strm indent;                  PP.openHOVBox strm indent;
440                    PP.cut strm;                    PP.cut strm;
441                    ppList {                    ppCommaList {
442                        pp = fn e => (PP.openHBox strm; ppExp e; PP.closeBox strm),                        pp = fn e => (PP.openHBox strm; ppExp e; PP.closeBox strm),
                       sep = fn () => (str ","; sp()),  
443                        l = args                        l = args
444                      };                      };
445                    str ")";                    str ")";

Legend:
Removed from v.3993  
changed lines
  Added in v.3994

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