Work in progress

rtree-c/src/ReduceC.hs

@@ -28,12 +28,14 @@ import qualified Language.C.Data.Ident as C
 data Context = Context
   { keywords :: !(Set.Set Keyword)
   , typeDefs :: !(Map.Map C.Ident [C.CDeclarationSpecifier C.NodeInfo])
+  , inlineExprs :: !(Map.Map C.Ident C.CExpr)
   }
 
 data Keyword
   = KeepMain
   | DoNoops
   | NoSemantics
+  | AllowEmptyDeclarations
   deriving (Show, Read, Enum, Eq, Ord)
 
 type CM m = (MonadReduce (String, C.Position) m, MonadReader Context m, MonadFail m)
@@ -49,11 +51,19 @@ addTypeDefs ids cs Context{..} =
     , ..
     }
 
+addInlineExpr :: C.Ident -> C.CExpr -> Context -> Context
+addInlineExpr i e Context{..} =
+  Context
+    { inlineExprs = Map.insert i e inlineExprs
+    , ..
+    }
+
 defaultContext :: Context
 defaultContext =
   Context
     { keywords = Set.fromList [KeepMain]
     , typeDefs = Map.empty
+    , inlineExprs = Map.empty
     }
 
 keyword :: (MonadReader Context m) => Keyword -> m Bool
@@ -87,9 +97,37 @@ instance CReducible C.CTranslUnit where
                 ("inline typedef " <> C.identToString ids, C.posOf r)
                 (local (addTypeDefs [ids] rst) cont)
                 ((r :) <$> local (addTypeDefs [ids] [C.CTypeSpec (C.CTypeDef ids n)]) cont)
+            -- A const
+            C.CDecl rec decl ni' -> do
+              (decl', cont') <- foldr reduceCDeclarationItem (pure ([], cont)) decl
+              allow <- keyword AllowEmptyDeclarations
+              case decl' of
+                []
+                  | allow ->
+                      split ("remove empty declaration", C.posOf r) cont' do
+                        (C.CDeclExt (C.CDecl rec decl' ni') :) <$> cont'
+                  | otherwise -> cont'
+                _ow -> (C.CDeclExt (C.CDecl rec decl' ni') :) <$> cont'
             a -> don'tHandle a
         _r -> don'tHandle r
 
+reduceCDeclarationItem
+  :: (CM m)
+  => C.CDeclarationItem C.NodeInfo
+  -> m ([C.CDeclarationItem C.NodeInfo], m a)
+  -> m ([C.CDeclarationItem C.NodeInfo], m a)
+reduceCDeclarationItem d ma = case d of
+  C.CDeclarationItem
+    (C.CDeclr (Just i) [] Nothing [] ni)
+    (Just (C.CInitExpr c _))
+    Nothing -> do
+      (ds, cont) <- ma
+      split
+        ("inline variable " <> C.identToString i, C.posOf ni)
+        (pure (ds, local (addInlineExpr i c) cont))
+        (pure (d : ds, local (addInlineExpr i (C.CVar i ni)) cont))
+  a -> don'tHandle a
+
 prettyIdent :: C.Identifier C.NodeInfo -> [Char]
 prettyIdent (C.Ident s _ a) = s ++ " at " ++ show (C.posOfNode a)
 
@@ -109,10 +147,18 @@ reduceCCompoundBlockItem r cont = case r of
     split ("remove statement", C.posOf r) cont do
       smt' <- reduceC smt
       (C.CBlockStmt smt' :) <$> cont
-  C.CBlockDecl decl -> do
-    case decl of
-      C.CDecl{} -> do
-        (r :) <$> cont
+  C.CBlockDecl declr -> do
+    case declr of
+      C.CDecl rec decl ni' -> do
+        (decl', cont') <- foldr reduceCDeclarationItem (pure ([], cont)) decl
+        allow <- keyword AllowEmptyDeclarations
+        case decl' of
+          []
+            | allow ->
+                split ("remove empty declaration", C.posOf r) cont' do
+                  (C.CBlockDecl (C.CDecl rec decl' ni') :) <$> cont'
+            | otherwise -> cont'
+          _ow -> (C.CBlockDecl (C.CDecl rec decl' ni') :) <$> cont'
       d -> don'tHandle d
   a -> don'tHandle a
 
@@ -142,15 +188,6 @@ instance CReducible (C.CStatement C.NodeInfo) where
           pure $ C.CReturn Nothing ni
     a -> don'tHandle a
 
-splitIf :: (MonadReduce l m) => Bool -> l -> m a -> m a -> m a
-splitIf True s a b = split s a b
-splitIf False _ _ b = b
-
-splitOn :: (MonadReduce l m, MonadReader Context m) => Keyword -> l -> m a -> m a -> m a
-splitOn k s a b = do
-  con <- keyword k
-  splitIf con s a b
-
 --     C.CCompound is cbi ni -> do
 --       cbi' <- collect (reduce @C.CCompoundBlockItem) cbi
 --       pure $ C.CCompound is cbi' ni
@@ -214,8 +251,10 @@ instance CReducible C.CExpr where
           elhs' <- reduceC elhs
           erhs' <- reduceC erhs
           pure $ C.CBinary o elhs' erhs' ni
-    C.CVar i ni -> do
-      pure $ C.CVar i ni
+    C.CVar i _ -> do
+      asks (Map.lookup i . inlineExprs) >>= \case
+        Just mx -> pure mx
+        Nothing -> fail ("Could not find " <> show i)
     C.CConst x -> do
       pure $ C.CConst x
     C.CUnary o elhs ni -> do
@@ -264,6 +303,15 @@ instance CReducible C.CExpr where
 --    where
 --     onBothExpr elhs erhs = onBoth (reduce elhs) (reduce erhs)
 
+splitIf :: (MonadReduce l m) => Bool -> l -> m a -> m a -> m a
+splitIf True s a b = split s a b
+splitIf False _ _ b = b
+
+splitOn :: (MonadReduce l m, MonadReader Context m) => Keyword -> l -> m a -> m a -> m a
+splitOn k s a b = do
+  con <- keyword k
+  splitIf con s a b
+
 inlineTypeDefs :: forall d m. (Data d, MonadFail m, MonadReader Context m) => d -> m d
 inlineTypeDefs r = do
   case eqT @d @[C.CDeclarationSpecifier C.NodeInfo] of

rtree-c/test/cases/constant.c

+int x = 10;
+
+int main () { 
+  int y = 25;
+  return x + y;
+}

rtree-c/test/expected/constant/main.c

+int x = 10;
+int main()
+{
+    int y = 25;
+    return x + y;
+}

rtree-c/test/expected/constant/reduction/r000.c

+int x = 10;
+int main()
+{
+    int y = 25;
+    return x + y;
+}

rtree-c/test/expected/constant/reduction/r000.choices

+0 remove statement at ("test/cases/constant.c": line 5)
+0 inline variable y at ("test/cases/constant.c": line 4)
+0 inline variable x at ("test/cases/constant.c": line 1)

rtree-c/test/expected/constant/reduction/r001.c

+int x = 10;
+int main()
+{
+    int y = 25;
+}

rtree-c/test/expected/constant/reduction/r001.choices

+1 remove statement at ("test/cases/constant.c": line 5)
+0 inline variable y at ("test/cases/constant.c": line 4)
+0 inline variable x at ("test/cases/constant.c": line 1)

rtree-c/test/expected/constant/reduction/r010.c

+int x = 10;
+int main()
+{
+    return x + 25;
+}

rtree-c/test/expected/constant/reduction/r010.choices

+0 remove statement at ("test/cases/constant.c": line 5)
+1 inline variable y at ("test/cases/constant.c": line 4)
+0 inline variable x at ("test/cases/constant.c": line 1)

rtree-c/test/expected/while-loops/reduction/r1.c → rtree-c/test/expected/constant/reduction/r011.c

+int x = 10;
 int main()
 {
-    int i = 0;
 }

rtree-c/test/expected/constant/reduction/r011.choices

+1 remove statement at ("test/cases/constant.c": line 5)
+1 inline variable y at ("test/cases/constant.c": line 4)
+0 inline variable x at ("test/cases/constant.c": line 1)

rtree-c/test/expected/constant/reduction/r100.c

+int main()
+{
+    int y = 25;
+    return 10 + y;
+}

rtree-c/test/expected/constant/reduction/r100.choices

+0 remove statement at ("test/cases/constant.c": line 5)
+0 inline variable y at ("test/cases/constant.c": line 4)
+1 inline variable x at ("test/cases/constant.c": line 1)

rtree-c/test/expected/constant/reduction/r101.c

+int main()
+{
+    int y = 25;
+}

rtree-c/test/expected/constant/reduction/r101.choices

+1 remove statement at ("test/cases/constant.c": line 5)
+0 inline variable y at ("test/cases/constant.c": line 4)
+1 inline variable x at ("test/cases/constant.c": line 1)

rtree-c/test/expected/constant/reduction/r110.c

+int main()
+{
+    return 10 + 25;
+}

rtree-c/test/expected/constant/reduction/r110.choices

+0 remove statement at ("test/cases/constant.c": line 5)
+1 inline variable y at ("test/cases/constant.c": line 4)
+1 inline variable x at ("test/cases/constant.c": line 1)

rtree-c/test/expected/constant/reduction/r111.c

+int main()
+{
+}

rtree-c/test/expected/constant/reduction/r111.choices

+1 remove statement at ("test/cases/constant.c": line 5)
+1 inline variable y at ("test/cases/constant.c": line 4)
+1 inline variable x at ("test/cases/constant.c": line 1)