expression-statements and increment statement.

1 files changed, 26 insertions, 7 deletions

diff --git a/monkeypatch.hs b/monkeypatch.hs
index 54b9f47..eefc525 100644
--- a/monkeypatch.hs
+++ b/monkeypatch.hs
@@ -285,6 +285,14 @@ grokExpression (C.CCall (CVar fn _) exps _) = do
         , compIntro = Map.empty
         , comp      = hsvar hv
         }
+grokExpression (CStatExpr (CCompound idents xs _) _) = do
+    let (y,ys) = splitAt 1 (reverse xs)
+    y' <- case y of
+                [CBlockStmt (CExpr mexp ni)] -> Just $ CBlockStmt (CReturn mexp ni)
+                _                            -> Just (head y) -- Nothing FIXME
+    gs <- mapM grokStatement (reverse $ y' : ys)
+    let s = foldr applyComputation (Computation Map.empty Map.empty hsopUnit) gs
+    return $ (,) [] $ fmap (\xp -> Paren () xp) s
 grokExpression _ = Nothing
 
 
@@ -374,13 +382,24 @@ grokStatement (CBlockStmt (CIf exp (CCompound [] stmts _) Nothing _)) = do
         , compIntro = compIntro s
         , comp = Lambda () [hspvar k] $ If () (comp x) (comp s) (hsvar k)
         }
--- TODO CStatExpr
+grokStatement (CBlockStmt (CExpr (Just (CUnary CPostIncOp (CMember (CVar cv0 _) fld True _) _)) _)) = do
+    let k1 = uniqIdentifier "go" (varmap [fieldlbl,v])
+        fieldlbl = identToString fld
+        v = identToString cv0
+    return Computation
+            { compFree = varmap [v]
+            , compIntro = Map.empty
+            , comp = Lambda () [hspvar k1]
+                        $ infixOp
+                            (App () (App () (App () (hsvar "modify")
+                                                    (TypeApp () (TyPromoted () (PromotedString () fieldlbl fieldlbl))))
+                                            (hsvar v))
+                                    (hsvar "succ")) ">>" (hsvar k1)
+            }
 grokStatement (CBlockStmt (CExpr mexpr _)) = do
-    let (ss,pre) = fromMaybe ([],Computation Map.empty Map.empty id) $ do
-                        expr <- mexpr
-                        (ss,x) <- grokExpression expr
-                        return (ss, fmap (\e -> infixFn e "seq") x)
-        k = uniqIdentifier "go" (compFree s)
+    (ss,pre) <- maybe (Just $ (,) [] $ Computation Map.empty Map.empty id)
+                      (fmap (second (fmap (\e -> infixFn e "seq"))) . grokExpression) mexpr
+    let k = uniqIdentifier "go" (compFree s)
         s = foldr applyComputation (fmap ($ hsvar k) pre) ss
     return $ fmap (Lambda () [hspvar k]) s
 grokStatement (CBlockDecl (CDecl (t:ts) (v:vs) _)) = do
@@ -440,7 +459,7 @@ transpile o fname incs (CTranslUnit edecls _) = do
                             forM_ bdy $ \d -> putStrLn $ ppShow $ cleanTree d
                     else do
                         let mhask = do
-                                xs <- sequence $ map grokStatement bdy
+                                xs <- mapM grokStatement bdy
                                 return $ foldr applyComputation (Computation Map.empty Map.empty hsopUnit) xs
                         case mhask of
                             Just hask -> do printHeader