2 % (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
4 \section{Generate Java}
7 module PrintJava( compilationUnit ) where
11 import Char( toLower )
15 indent :: SDoc -> SDoc
19 %************************************************************************
21 \subsection{Pretty printer}
23 %************************************************************************
26 compilationUnit :: CompilationUnit -> SDoc
27 compilationUnit (Package n ds) = package n (decls ds)
29 package = \n -> \ds ->
30 text "package" <+> name n <> text ";"
35 decls (d:ds) = decl d $$ decls ds
39 { Import n -> importDecl (name n)
40 ; Field mfs t n e -> field (modifiers mfs) (typ t) (name n) e
41 ; Constructor mfs n as ss -> constructor (modifiers mfs) (name n) (parameters as) (statements ss)
42 ; Method mfs t n as ts ss -> method (modifiers mfs) (typ t) (name n) (parameters as) (throws ts) (statements ss)
43 ; Comment s -> comment s
44 ; Interface mfs n is ms -> interface (modifiers mfs) (name n) (extends is) (decls ms)
45 ; Class mfs n x is ms -> clazz (modifiers mfs) (name n) (extends x) (implements is) (decls ms)
48 importDecl n = text "import" <+> n <> text ";"
50 field = \mfs -> \t -> \n -> \e ->
52 { Nothing -> mfs <+> t <+> n <> text ";"
53 ; Just e -> lay [mfs <+> t <+> n <+> text "=", indent (expr e <> text ";")]
55 lay | isSimple e = hsep
59 constructor = \mfs -> \n -> \as -> \ss ->
60 mfs <+> n <+> parens (hsep (punctuate comma as)) <+> text "{"
64 method = \mfs -> \t -> \n -> \as -> \ts -> \ss ->
65 mfs <+> t <+> n <+> parens (hsep (punctuate comma as)) <+> ts <+> text "{"
71 $$ indent (vcat [ text s | s <- ss])
74 interface = \mfs -> \n -> \xs -> \ms ->
75 mfs <+> n <+> xs <+> text "{"
79 clazz = \mfs -> \n -> \x -> \is -> \ms ->
80 mfs <+> text "class" <+> n <+> x <+> is <+> text "{"
85 text "static" <+> text "{"
89 modifiers mfs = hsep (map modifier mfs)
91 modifier mf = text $ map toLower (show mf)
94 extends xs = text "extends" <+> hsep (punctuate comma (map name xs))
97 implements xs = text "implements" <+> hsep (punctuate comma (map name xs))
100 throws xs = text "throws" <+> hsep (punctuate comma (map name xs))
104 parameters as = map parameter as
106 parameter (Parameter mfs t n) = modifiers mfs <+> typ t <+> name n
108 typ (PrimType s) = primtype s
109 typ (Type n) = name n
110 typ (ArrayType t) = typ t <> text "[]"
112 primtype PrimInt = text "int"
113 primtype PrimBoolean = text "boolean"
114 primtype PrimChar = text "char"
115 primtype PrimLong = text "long"
116 primtype PrimFloat = text "float"
117 primtype PrimDouble = text "double"
118 primtype PrimByte = text "byte"
122 statements ss = vcat (map statement ss)
127 ; Return e -> returnStat (expr e)
128 ; Block ss -> vcat [statement s | s <- ss]
129 ; ExprStatement e -> exprStatement (expr e)
130 ; Declaration d -> declStatement (decl d)
131 ; IfThenElse ecs s -> ifthenelse [ (expr e, statement s) | (e,s) <- ecs ] (maybe Nothing (Just .statement) s)
132 ; Switch e as d -> switch (expr e) (arms as) (deflt d)
137 returnStat e = sep [text "return", indent e <> semi]
139 exprStatement e = e <> semi
143 ifthenelse ((e,s):ecs) ms = sep [text "if" <+> parens e <+> text "{",
147 thenelse ((e,s):ecs) ms = sep [ text "} else if" <+> parens e <+> text "{",
151 thenelse [] Nothing = text "}"
152 thenelse [] (Just s) = sep [text "} else {", indent s, text "}"]
154 switch = \e -> \as -> \d ->
155 text "switch" <+> parens e <+> text "{"
159 deflt Nothing = empty
160 deflt (Just ss) = text "default:" $$ indent (statements ss)
163 arms ((e,ss):as) = text "case" <+> expr e <> colon
164 $$ indent (statements ss)
167 maybeExpr Nothing = Nothing
168 maybeExpr (Just e) = Just (expr e)
173 ; Literal l _ -> literal l
174 ; Cast t e -> cast (typ t) e
175 ; Access e n -> expr e <> text "." <> name n
176 ; Assign l r -> assign (expr l) r
177 ; New n es ds -> new (typ n) es (maybeClass ds)
178 ; Call e n es -> call (expr e) (name n) es
179 ; Op e1 o e2 -> op e1 o e2
180 ; InstanceOf e t -> expr e <+> text "instanceof" <+> typ t
183 op = \e1 -> \o -> \e2 ->
186 else parens (expr e1)
193 else parens (expr e2)
198 then l <+> text "=" <+> (expr r)
199 else l <+> text "=" $$ indent (expr r)
203 then parens (parens t <> expr e)
204 else parens (parens t $$ indent (expr e))
206 new n [] (Just ds) = sep [text "new" <+> n <+> text "()" <+> text "{",
209 new n es Nothing = text "new" <+> n <> parens (hsep (punctuate comma (map expr es)))
212 call e n es = e <> dot <> n <> parens (hsep (punctuate comma (map expr es)))
216 { IntLit i -> text (show i)
217 ; UIntLit i -> text (show i)
218 ; CharLit c -> text (show c)
219 ; UCharLit c -> text (show c)
220 ; StringLit s -> text (show s)
223 maybeClass Nothing = Nothing
224 maybeClass (Just ds) = Just (decls ds)