Add probabilities to generation of expressions

7 files changed, 51 insertions, 37 deletions

diff --git a/src/VeriFuzz/Config.hs b/src/VeriFuzz/Config.hs
index d072e74..ec3fbc1 100644
--- a/src/VeriFuzz/Config.hs
+++ b/src/VeriFuzz/Config.hs
@@ -115,7 +115,7 @@ defaultConfig :: Config
 defaultConfig = Config (Probability defModItem defStmnt defExpr) (Property 20 Nothing 3)
     where defModItem = ProbModItem 5 1
           defStmnt = ProbStatement 5 5 1
-          defExpr = ProbExpr 1 1 1 1 1 1 1 1 1
+          defExpr = ProbExpr 1 1 1 1 1 1 0 1 1
 
 twoKey :: Toml.Piece -> Toml.Piece -> Toml.Key
 twoKey a b = Toml.Key (a :| [b])
diff --git a/src/VeriFuzz/Verilog.hs b/src/VeriFuzz/Verilog.hs
index a45922b..752b754 100644
--- a/src/VeriFuzz/Verilog.hs
+++ b/src/VeriFuzz/Verilog.hs
@@ -117,7 +117,6 @@ module VeriFuzz.Verilog
     , Arb
     , arb
     , genPositive
-    , exprWithContext
     )
 where
 
diff --git a/src/VeriFuzz/Verilog/AST.hs b/src/VeriFuzz/Verilog/AST.hs
index f84eddf..270793d 100644
--- a/src/VeriFuzz/Verilog/AST.hs
+++ b/src/VeriFuzz/Verilog/AST.hs
@@ -211,7 +211,7 @@ data UnaryOperator = UnPlus    -- ^ @+@
                    deriving (Eq, Show, Ord, Data)
 
 data Function = SignedFunc
-              | UnSignedFunc
+              | UnsignedFunc
               deriving (Eq, Show, Ord, Data)
 
 -- | Verilog expression, which can either be a primary expression, unary
diff --git a/src/VeriFuzz/Verilog/Arbitrary.hs b/src/VeriFuzz/Verilog/Arbitrary.hs
index 6655309..40b9787 100644
--- a/src/VeriFuzz/Verilog/Arbitrary.hs
+++ b/src/VeriFuzz/Verilog/Arbitrary.hs
@@ -16,7 +16,6 @@ module VeriFuzz.Verilog.Arbitrary
       Arb
     , arb
     , genPositive
-    , exprWithContext
     , listOf1
     , listOf
     )
@@ -109,7 +108,7 @@ instance Arb UnaryOperator where
 instance Arb Function where
     arb = Hog.element
         [ SignedFunc
-        , UnSignedFunc
+        , UnsignedFunc
         ]
 
 instance Arb Expr where
@@ -137,17 +136,6 @@ expr n | n == 0    = Hog.choice $ (Id <$> arb) : exprSafeList
        | otherwise = expr 0
     where subexpr y = expr (n `div` y)
 
-exprWithContext :: [Identifier] -> Hog.Size -> Gen Expr
-exprWithContext [] n | n == 0    = Hog.choice exprSafeList
-                     | n > 0     = Hog.choice $ exprRecList subexpr
-                     | otherwise = exprWithContext [] 0
-    where subexpr y = exprWithContext [] (n `div` y)
-exprWithContext l n
-    | n == 0    = Hog.choice $ (Id <$> Hog.element l) : exprSafeList
-    | n > 0     = Hog.choice $ (Id <$> Hog.element l) : exprRecList subexpr
-    | otherwise = exprWithContext l 0
-    where subexpr y = exprWithContext l (n `div` y)
-
 constExpr :: Gen ConstExpr
 constExpr = Hog.recursive Hog.choice
             [ ConstNum <$> genPositive <*> arb
diff --git a/src/VeriFuzz/Verilog/CodeGen.hs b/src/VeriFuzz/Verilog/CodeGen.hs
index 0ac548a..2479d39 100644
--- a/src/VeriFuzz/Verilog/CodeGen.hs
+++ b/src/VeriFuzz/Verilog/CodeGen.hs
@@ -129,7 +129,7 @@ contAssign (ContAssign val e) =
 -- | Generate 'Function' to 'Text'
 func :: Function -> Text
 func SignedFunc   = "$signed"
-func UnSignedFunc = "$unsigned"
+func UnsignedFunc = "$unsigned"
 
 -- | Generate 'Expr' to 'Text'.
 expr :: Expr -> Text
diff --git a/src/VeriFuzz/Verilog/Gen.hs b/src/VeriFuzz/Verilog/Gen.hs
index ae72b9f..6ec422d 100644
--- a/src/VeriFuzz/Verilog/Gen.hs
+++ b/src/VeriFuzz/Verilog/Gen.hs
@@ -59,7 +59,7 @@ sumSize ps = sum $ ps ^.. traverse . portSize
 
 random :: [Identifier] -> (Expr -> ContAssign) -> Gen ModItem
 random ctx fun = do
-    expr <- Hog.sized (exprWithContext ctx)
+    expr <- Hog.sized (exprWithContext (ProbExpr 1 1 1 1 1 1 0 1 1) ctx)
     return . ModCA $ fun expr
 
 --randomAssigns :: [Identifier] -> [Gen ModItem]
@@ -86,6 +86,49 @@ randomMod inps total = do
 gen :: Gen a -> StateGen a
 gen = lift . lift
 
+constExprWithContext :: [Parameter] -> ProbExpr -> Hog.Size -> Gen ConstExpr
+constExprWithContext ps prob size
+    | size == 0 = Hog.frequency
+                  [ (prob ^. probExprNum, ConstNum <$> genPositive <*> arb)
+                  , (if null ps then 0 else prob ^. probExprId, ParamId . view paramIdent <$> Hog.element ps)
+                  ]
+    | size > 0 = Hog.frequency
+                 [ (prob ^. probExprNum, ConstNum <$> genPositive <*> arb)
+                 , (if null ps then 0 else prob ^. probExprId, ParamId . view paramIdent <$> Hog.element ps)
+                 , (prob ^. probExprUnOp, ConstUnOp <$> arb <*> subexpr 2)
+                 , (prob ^. probExprBinOp, ConstBinOp <$> subexpr 2 <*> arb <*> subexpr 2)
+                 , (prob ^. probExprCond, ConstCond <$> subexpr 3 <*> subexpr 3 <*> subexpr 3)
+                 , (prob ^. probExprConcat, ConstConcat <$> listOf1 (subexpr 8))
+                 ]
+    | otherwise = constExprWithContext ps prob 0
+    where subexpr y = constExprWithContext ps prob $ size `div` y
+
+exprSafeList :: ProbExpr -> [(Int, Gen Expr)]
+exprSafeList prob = [(prob ^. probExprNum, Number <$> genPositive <*> Hog.integral (Hog.linearFrom 0 (-100) 100))]
+
+exprRecList :: ProbExpr -> (Hog.Size -> Gen Expr) -> [(Int, Gen Expr)]
+exprRecList prob subexpr =
+    [ (prob ^. probExprNum, Number <$> genPositive <*> Hog.integral (Hog.linearFrom 0 (-100) 100))
+    , (prob ^. probExprConcat, Concat <$> listOf1 (subexpr 8))
+    , (prob ^. probExprUnOp, UnOp <$> arb <*> subexpr 2)
+    , (prob ^. probExprStr, Str <$> Hog.text (Hog.linear 0 100) Hog.alphaNum)
+    , (prob ^. probExprBinOp, BinOp <$> subexpr 2 <*> arb <*> subexpr 2)
+    , (prob ^. probExprCond, Cond <$> subexpr 3 <*> subexpr 3 <*> subexpr 3)
+    , (prob ^. probExprSigned, Func <$> pure SignedFunc <*> subexpr 2)
+    , (prob ^. probExprUnsigned, Func <$> pure UnsignedFunc <*> subexpr 2)
+    ]
+
+exprWithContext :: ProbExpr -> [Identifier] -> Hog.Size -> Gen Expr
+exprWithContext prob [] n | n == 0    = Hog.frequency $ exprSafeList prob
+                          | n > 0     = Hog.frequency $ exprRecList prob subexpr
+                          | otherwise = exprWithContext prob [] 0
+    where subexpr y = exprWithContext prob [] $ n `div` y
+exprWithContext prob l n
+    | n == 0    = Hog.frequency $ (prob ^. probExprId, Id <$> Hog.element l) : exprSafeList prob
+    | n > 0     = Hog.frequency $ (prob ^. probExprId, Id <$> Hog.element l) : exprRecList prob subexpr
+    | otherwise = exprWithContext prob l 0
+    where subexpr y = exprWithContext prob l $ n `div` y
+
 some :: StateGen a -> StateGen [a]
 some f = do
     amount <- gen genPositive
@@ -116,9 +159,10 @@ choose ptype (Port a _ _ _) = ptype == a
 scopedExpr :: StateGen Expr
 scopedExpr = do
     context <- get
+    prob <- askProbability
     gen
         .   Hog.sized
-        .   exprWithContext
+        .   exprWithContext (prob ^. probExpr)
         $   context
         ^.. variables
         .   traverse
@@ -193,23 +237,6 @@ initialBlock = do
     where
         makeAssign p = NonBlockAssign $ Assign (lvalFromPort p) Nothing 0
 
-constExprWithContext :: [Parameter] -> ProbExpr -> Hog.Size -> Gen ConstExpr
-constExprWithContext ps prob size
-    | size == 0 = Hog.frequency
-                  [ (prob ^. probExprNum, ConstNum <$> genPositive <*> arb)
-                  , (if null ps then 0 else prob ^. probExprId, ParamId . view paramIdent <$> Hog.element ps)
-                  ]
-    | size > 0 = Hog.frequency
-                 [ (prob ^. probExprNum, ConstNum <$> genPositive <*> arb)
-                 , (if null ps then 0 else prob ^. probExprId, ParamId . view paramIdent <$> Hog.element ps)
-                 , (prob ^. probExprUnOp, ConstUnOp <$> arb <*> subexpr 2)
-                 , (prob ^. probExprBinOp, ConstBinOp <$> subexpr 2 <*> arb <*> subexpr 2)
-                 , (prob ^. probExprCond, ConstCond <$> subexpr 3 <*> subexpr 3 <*> subexpr 3)
-                 , (prob ^. probExprConcat, ConstConcat <$> listOf1 (subexpr 8))
-                 ]
-    | otherwise = constExprWithContext ps prob 0
-    where subexpr y = constExprWithContext ps prob $ size `div` y
-
 constExpr :: StateGen ConstExpr
 constExpr = do
     prob <- askProbability
diff --git a/src/VeriFuzz/Verilog/Parser.hs b/src/VeriFuzz/Verilog/Parser.hs
index 1a954fa..8c9a986 100644
--- a/src/VeriFuzz/Verilog/Parser.hs
+++ b/src/VeriFuzz/Verilog/Parser.hs
@@ -106,7 +106,7 @@ systemFunc s = satisfy' matchId
 parseFunction :: Parser Function
 parseFunction =
     systemFunc "$unsigned"
-        $>  UnSignedFunc
+        $>  UnsignedFunc
         <|> systemFunc "$signed"
         $>  SignedFunc