[treat operators of constant C values as atomic, as well as memory addresses and string constants
John Meacham <john@repetae.net>**20060316063554] hunk ./C/FromGrin.hs 70
-convertVal x = return $ err (show x)
+convertVal (ValPrim (APrim p _) [] _) = case p of
+    CConst s _ -> return $ expressionRaw s
+    AddrOf t -> return $ expressionRaw ('&':t)
+    x -> return $ err ("convertVal: " ++ show x)
+convertVal (ValPrim (APrim p _) [x] _) = do
+    x' <- convertVal x
+    case p of
+        CCast _ to -> return $ cast (basicType to) x'
+        Operator n [_] r ->  return $ cast (basicType r) (uoperator n x')
+        x -> return $ err ("convertVal: " ++ show x)
+convertVal (ValPrim (APrim p _) [x,y] _) = do
+    x' <- convertVal x
+    y' <- convertVal y
+    case p of
+        Operator n [_,_] r -> return $ cast (basicType r) (operator n x' y')
+        x -> return $ err ("convertVal: " ++ show x)
+
+convertVal x = return $ err ("convertVal: " ++ show x)
hunk ./C/FromGrin.hs 406
-        f (Left (Lit i _)) = tshow i
-        f (Left (Tag t)) = tshow (nodeTagName t)
+        f (Left v) | Just e <- convertConst v = text (show $ drawG e)
+--        f (Left (Lit i _)) = tshow i
+--        f (Left vp@(ValPrim {})) = tshow i
+--        f (Left (Tag t)) = tshow (nodeTagName t)
+
+convertConst :: Monad m => Val -> m Expression
+convertConst (Const (NodeC h _)) | h == tagHole = return nullPtr
+convertConst (Lit i _) = return (constant $ number (fromIntegral i))
+convertConst (Tup [x]) = convertConst x
+convertConst (Tup []) = return emptyExpression
+convertConst (Tag t) = return $ constant (enum $ nodeTagName t)
+convertConst (ValPrim (APrim p _) [] _) = case p of
+    CConst s _ -> return $ expressionRaw s
+    AddrOf t -> return $ expressionRaw ('&':t)
+    x -> return $ err (show x)
+convertConst (ValPrim (APrim p _) [x] _) = do
+    x' <- convertConst x
+    case p of
+        CCast _ to -> return $ cast (basicType to) x'
+        Operator n [_] r ->  return $ cast (basicType r) (uoperator n x')
+        x -> return $ err (show x)
+convertConst (ValPrim (APrim p _) [x,y] _) = do
+    x' <- convertConst x
+    y' <- convertConst y
+    case p of
+        Operator n [_,_] r -> return $ cast (basicType r) (operator n x' y')
+        x -> return $ err (show x)
+
+convertConst x = fail "convertConst"
+
hunk ./C/Prims.hs 49
--- primIsConstant CConst {} = True
--- primIsConstant AddrOf {} = True
--- primIsConstant CCast {} = True -- grin doesn't support this yet
--- primIsConstant Operator {} = True -- inhibits rules matching, divide by zero.
+primIsConstant CConst {} = True
+primIsConstant AddrOf {} = True
+primIsConstant CCast {} = True
+primIsConstant Operator { primOp = op } | op `elem` safeOps = True  where
+    safeOps = ["+","-","*","==",">=","<=",">","<","&","|","^","~",">>","<<"]
hunk ./E/SSimplify.hs 395
+    -- atomic unboxed values may be substituted or discarded without replicating work or affecting program semantics.
+    doCase e _ b [] (Just d) sub inb | isUnboxed (getType e), isAtomic e = do
+        mtick "E.Simplify.case-atomic-unboxed"
+        f d (Map.insert (tvrNum b) (Susp e sub) sub) inb
hunk ./Grin/FromE.hs 547
+    literal (EPrim aprim@(APrim p _) xs (ELit (LitCons n [] (ESort EHash)))) | RawType <- nameType n, primIsConstant p = do
+        xs <- mapM literal xs
+        return $ ValPrim aprim xs (Ty $ toAtom (show n))
hunk ./Grin/Grin.hs 165
-    | ValPrim APrim
+    | ValPrim APrim [Val] Ty
hunk ./Grin/Grin.hs 192
+    showsPrec _ (ValPrim aprim xs _) = tshow aprim <> tupled (map tshow xs)
hunk ./Grin/Grin.hs 463
-    typecheck _ (ValPrim _) = error "ValPrim"
+    typecheck _ (ValPrim _ _ ty) = return ty
hunk ./Grin/Grin.hs 494
-    getType (ValPrim _) = error "ValPrim"
+    getType (ValPrim _ _ ty) = ty
hunk ./Grin/HashConst.hs 31
+            g vp@(ValPrim _ _ ty)
+                | fuzzy = return $ Left (Lit 0 ty)
+                | otherwise = return $ Left vp
hunk ./Grin/Linear.hs 75
+    omegaize ValPrim {} = return ()
hunk ./Grin/PointsToAnalysis.hs 218
+bind (NodeC t [ValPrim {}]) _ = return ()
hunk ./Grin/PointsToAnalysis.hs 534
+toPos (ValPrim {}) = return Basic
hunk ./Grin/Show.hs 93
+prettyVal (ValPrim aprim xs ty) = tshow aprim <> tupled (map tshow xs)