--- a/tools/pas2c.hs Mon Dec 05 23:52:59 2011 -0500
+++ b/tools/pas2c.hs Tue Dec 06 17:59:10 2011 +0400
@@ -101,17 +101,22 @@
uses2List :: Uses -> [String]
uses2List (Uses ids) = map (\(Identifier i _) -> i) ids
+id2C :: Bool -> Identifier -> Reader a Doc
+id2C isDecl (Identifier i _) = return $ text i
+
tvar2C :: Bool -> TypeVarDeclaration -> Reader a Doc
-tvar2C _ (FunctionDeclaration (Identifier name _) returnType params Nothing) = do
+tvar2C _ (FunctionDeclaration name returnType params Nothing) = do
t <- type2C returnType
p <- liftM hcat $ mapM (tvar2C False) params
- return $ t <+> text name <> parens p <> text ";"
-tvar2C True (FunctionDeclaration (Identifier name _) returnType params (Just (tvars, phrase))) = do
+ n <- id2C True name
+ return $ t <+> n <> parens p <> text ";"
+tvar2C True (FunctionDeclaration name returnType params (Just (tvars, phrase))) = do
t <- type2C returnType
p <- liftM hcat $ mapM (tvar2C False) params
ph <- liftM2 ($+$) (typesAndVars2C False tvars) (phrase2C' phrase)
+ n <- id2C True name
return $
- t <+> text name <> parens p
+ t <+> n <> parens p
$+$
text "{"
$+$
@@ -125,66 +130,106 @@
tvar2C _ (TypeDeclaration (Identifier i _) t) = do
tp <- type2C t
return $ text "type" <+> text i <+> tp <> text ";"
-tvar2C _ (VarDeclaration isConst (ids, t) mInitExpr) =
- if isConst then text "const" else empty
- <+>
- type2C t
- <+>
- (hsep . punctuate (char ',') . map (\(Identifier i _) -> text i) $ ids)
- <+>
- initExpr mInitExpr
- <>
- text ";"
+tvar2C _ (VarDeclaration isConst (ids, t) mInitExpr) = do
+ t' <- type2C t
+ i <- mapM (id2C True) ids
+ ie <- initExpr mInitExpr
+ return $ if isConst then text "const" else empty
+ <+> t'
+ <+> (hsep . punctuate (char ',') $ i)
+ <+> ie
+ <> text ";"
where
- initExpr Nothing = empty
- initExpr (Just e) = text "=" <+> initExpr2C e
+ initExpr Nothing = return $ empty
+ initExpr (Just e) = liftM (text "=" <+>) (initExpr2C e)
tvar2C f (OperatorDeclaration op _ ret params body) =
tvar2C f (FunctionDeclaration (Identifier ("<op " ++ op ++ ">") Unknown) ret params body)
initExpr2C :: InitExpression -> Reader a Doc
-initExpr2C (InitBinOp op expr1 expr2) = parens $ (initExpr2C expr1) <+> op2C op <+> (initExpr2C expr2)
-initExpr2C (InitNumber s) = text s
-initExpr2C (InitFloat s) = text s
-initExpr2C (InitHexNumber s) = text "0x" <> (text . map toLower $ s)
-initExpr2C (InitString s) = doubleQuotes $ text s
-initExpr2C (InitReference (Identifier i _)) = text i
+initExpr2C (InitBinOp op expr1 expr2) = do
+ e1 <- initExpr2C expr1
+ e2 <- initExpr2C expr2
+ o <- op2C op
+ return $ parens $ e1 <+> o <+> e2
+initExpr2C (InitNumber s) = return $ text s
+initExpr2C (InitFloat s) = return $ text s
+initExpr2C (InitHexNumber s) = return $ text "0x" <> (text . map toLower $ s)
+initExpr2C (InitString s) = return $ doubleQuotes $ text s
+initExpr2C (InitReference i) = id2C False i
+initExpr2C _ = return $ text "<<expression>>"
-initExpr2C _ = text "<<expression>>"
-
type2C :: TypeDecl -> Reader a Doc
-type2C UnknownType = text "void"
-type2C (String l) = text $ "string" ++ show l
-type2C (SimpleType (Identifier i _)) = text i
-type2C (PointerTo t) = type2C t <> text "*"
-type2C (RecordType tvs union) = text "{" $+$ (nest 4 . vcat . map (tvar2C False) $ tvs) $+$ text "}"
-type2C (RangeType r) = text "<<range type>>"
-type2C (Sequence ids) = text "<<sequence type>>"
-type2C (ArrayDecl r t) = text "<<array type>>"
-type2C (Set t) = text "<<set>>"
-type2C (FunctionType returnType params) = text "<<function>>"
+type2C UnknownType = return $ text "void"
+type2C (String l) = return $ text $ "string" ++ show l
+type2C (SimpleType i) = id2C True i
+type2C (PointerTo t) = liftM (<> text "*") $ type2C t
+type2C (RecordType tvs union) = do
+ t <- mapM (tvar2C False) tvs
+ return $ text "{" $+$ (nest 4 . vcat $ t) $+$ text "}"
+type2C (RangeType r) = return $ text "<<range type>>"
+type2C (Sequence ids) = return $ text "<<sequence type>>"
+type2C (ArrayDecl r t) = return $ text "<<array type>>"
+type2C (Set t) = return $ text "<<set>>"
+type2C (FunctionType returnType params) = return $ text "<<function>>"
phrase2C :: Phrase -> Reader a Doc
-phrase2C (Phrases p) = text "{" $+$ (nest 4 . vcat . map phrase2C $ p) $+$ text "}"
-phrase2C (ProcCall f@(FunCall {}) []) = ref2C f <> semi
-phrase2C (ProcCall ref params) = ref2C ref <> parens (hsep . punctuate (char ',') . map expr2C $ params) <> semi
-phrase2C (IfThenElse (expr) phrase1 mphrase2) = text "if" <> parens (expr2C expr) $+$ (phrase2C . wrapPhrase) phrase1 $+$ elsePart
+phrase2C (Phrases p) = do
+ ps <- mapM phrase2C p
+ return $ text "{" $+$ (nest 4 . vcat $ ps) $+$ text "}"
+phrase2C (ProcCall f@(FunCall {}) []) = liftM (<> semi) $ ref2C f
+phrase2C (ProcCall ref params) = do
+ r <- ref2C ref
+ ps <- mapM expr2C params
+ return $ r <> parens (hsep . punctuate (char ',') $ ps) <> semi
+phrase2C (IfThenElse (expr) phrase1 mphrase2) = do
+ e <- expr2C expr
+ p1 <- (phrase2C . wrapPhrase) phrase1
+ el <- elsePart
+ return $
+ text "if" <> parens e $+$ p1 $+$ el
where
- elsePart | isNothing mphrase2 = empty
- | otherwise = text "else" $$ (phrase2C . wrapPhrase) (fromJust mphrase2)
-phrase2C (Assignment ref expr) = ref2C ref <> text " = " <> expr2C expr <> semi
-phrase2C (WhileCycle expr phrase) = text "while" <> parens (expr2C expr) $$ (phrase2C $ wrapPhrase phrase)
-phrase2C (SwitchCase expr cases mphrase) = text "switch" <> parens (expr2C expr) <> text "of" $+$ (nest 4 . vcat . map case2C) cases
+ elsePart | isNothing mphrase2 = return $ empty
+ | otherwise = liftM (text "else" $$) $ (phrase2C . wrapPhrase) (fromJust mphrase2)
+phrase2C (Assignment ref expr) = do
+ r <- ref2C ref
+ e <- expr2C expr
+ return $
+ r <> text " = " <> e <> semi
+phrase2C (WhileCycle expr phrase) = do
+ e <- expr2C expr
+ p <- phrase2C $ wrapPhrase phrase
+ return $ text "while" <> parens e $$ p
+phrase2C (SwitchCase expr cases mphrase) = do
+ e <- expr2C expr
+ cs <- mapM case2C cases
+ return $
+ text "switch" <> parens e <> text "of" $+$ (nest 4 . vcat) cs
where
- case2C :: ([InitExpression], Phrase) -> Doc
- case2C (e, p) = text "case" <+> parens (hsep . punctuate (char ',') . map initExpr2C $ e) <> char ':' <> nest 4 (phrase2C p $+$ text "break;")
-phrase2C (WithBlock ref p) = text "namespace" <> parens (ref2C ref) $$ (phrase2C $ wrapPhrase p)
-phrase2C (ForCycle (Identifier i _) e1 e2 p) =
- text "for" <> (parens . hsep . punctuate (char ';') $ [text i <+> text "=" <+> expr2C e1, text i <+> text "<=" <+> expr2C e2, text "++" <> text i])
- $$
- phrase2C (wrapPhrase p)
-phrase2C (RepeatCycle e p) = text "do" <+> phrase2C (Phrases p) <+> text "while" <> parens (text "!" <> parens (expr2C e))
-phrase2C NOP = text ";"
+ case2C :: ([InitExpression], Phrase) -> Reader a Doc
+ case2C (e, p) = do
+ ie <- mapM initExpr2C e
+ ph <- phrase2C p
+ return $
+ text "case" <+> parens (hsep . punctuate (char ',') $ ie) <> char ':' <> nest 4 (ph $+$ text "break;")
+phrase2C (WithBlock ref p) = do
+ r <- ref2C ref
+ ph <- phrase2C $ wrapPhrase p
+ return $ text "namespace" <> parens r $$ ph
+phrase2C (ForCycle i' e1' e2' p) = do
+ i <- id2C False i'
+ e1 <- expr2C e1'
+ e2 <- expr2C e2'
+ ph <- phrase2C (wrapPhrase p)
+ return $
+ text "for" <> (parens . hsep . punctuate (char ';') $ [i <+> text "=" <+> e1, i <+> text "<=" <+> e2, text "++" <> i])
+ $$
+ ph
+phrase2C (RepeatCycle e' p') = do
+ e <- expr2C e'
+ p <- phrase2C (Phrases p')
+ return $ text "do" <+> p <+> text "while" <> parens (text "!" <> parens e)
+phrase2C NOP = return $ text ";"
wrapPhrase p@(Phrases _) = p
@@ -192,41 +237,71 @@
expr2C :: Expression -> Reader a Doc
-expr2C (Expression s) = text s
-expr2C (BinOp op expr1 expr2) = parens $ (expr2C expr1) <+> op2C op <+> (expr2C expr2)
-expr2C (NumberLiteral s) = text s
-expr2C (FloatLiteral s) = text s
-expr2C (HexNumber s) = text "0x" <> (text . map toLower $ s)
-expr2C (StringLiteral s) = doubleQuotes $ text s
+expr2C (Expression s) = return $ text s
+expr2C (BinOp op expr1 expr2) = do
+ e1 <- expr2C expr1
+ e2 <- expr2C expr2
+ o <- op2C op
+ return $ parens $ e1 <+> o <+> e2
+expr2C (NumberLiteral s) = return $ text s
+expr2C (FloatLiteral s) = return $ text s
+expr2C (HexNumber s) = return $ text "0x" <> (text . map toLower $ s)
+expr2C (StringLiteral s) = return $ doubleQuotes $ text s
expr2C (Reference ref) = ref2C ref
-expr2C (PrefixOp op expr) = op2C op <+> expr2C expr
-expr2C Null = text "NULL"
-expr2C (BuiltInFunCall params ref) = ref2C ref <> parens (hsep . punctuate (char ',') . map expr2C $ params)
-expr2C _ = text "<<expression>>"
+expr2C (PrefixOp op expr) = liftM2 (<+>) (op2C op) (expr2C expr)
+expr2C Null = return $ text "NULL"
+expr2C (BuiltInFunCall params ref) = do
+ r <- ref2C ref
+ ps <- mapM expr2C params
+ return $
+ r <> parens (hsep . punctuate (char ',') $ ps)
+expr2C _ = return $ text "<<expression>>"
ref2C :: Reference -> Reader a Doc
-ref2C (ArrayElement exprs ref) = ref2C ref <> (brackets . hcat) (punctuate comma $ map expr2C exprs)
-ref2C (SimpleReference (Identifier name _)) = text name
-ref2C (RecordField (Dereference ref1) ref2) = ref2C ref1 <> text "->" <> ref2C ref2
-ref2C (RecordField ref1 ref2) = ref2C ref1 <> text "." <> ref2C ref2
-ref2C (Dereference ref) = parens $ text "*" <> ref2C ref
-ref2C (FunCall params ref) = ref2C ref <> parens (hsep . punctuate (char ',') . map expr2C $ params)
-ref2C (Address ref) = text "&" <> parens (ref2C ref)
-ref2C (TypeCast (Identifier t _) expr) = parens (text t) <> expr2C expr
+ref2C (ArrayElement exprs ref) = do
+ r <- ref2C ref
+ es <- mapM expr2C exprs
+ return $ r <> (brackets . hcat) (punctuate comma es)
+ref2C (SimpleReference name) = id2C False name
+ref2C (RecordField (Dereference ref1) ref2) = do
+ r1 <- ref2C ref1
+ r2 <- ref2C ref2
+ return $
+ r1 <> text "->" <> r2
+ref2C (RecordField ref1 ref2) = do
+ r1 <- ref2C ref1
+ r2 <- ref2C ref2
+ return $
+ r1 <> text "." <> r2
+ref2C (Dereference ref) = liftM ((parens $ text "*") <>) $ ref2C ref
+ref2C (FunCall params ref) = do
+ r <- ref2C ref
+ ps <- mapM expr2C params
+ return $
+ r <> parens (hsep . punctuate (char ',') $ ps)
+ref2C (Address ref) = do
+ r <- ref2C ref
+ return $ text "&" <> parens r
+ref2C (TypeCast t' expr) = do
+ t <- id2C False t'
+ e <- expr2C expr
+ return $ parens t <> e
ref2C (RefExpression expr) = expr2C expr
-op2C "or" = text "|"
-op2C "and" = text "&"
-op2C "not" = text "!"
-op2C "xor" = text "^"
-op2C "div" = text "/"
-op2C "mod" = text "%"
-op2C "shl" = text "<<"
-op2C "shr" = text ">>"
-op2C "<>" = text "!="
-op2C "=" = text "=="
-op2C a = text a
+
+op2C :: String -> Reader a Doc
+op2C "or" = return $ text "|"
+op2C "and" = return $ text "&"
+op2C "not" = return $ text "!"
+op2C "xor" = return $ text "^"
+op2C "div" = return $ text "/"
+op2C "mod" = return $ text "%"
+op2C "shl" = return $ text "<<"
+op2C "shr" = return $ text ">>"
+op2C "<>" = return $ text "!="
+op2C "=" = return $ text "=="
+op2C a = return $ text a
maybeVoid "" = "void"
maybeVoid a = a